luau-lang/rfcs
1
0
Fork 0
mirror of https://github.com/luau-lang/rfcs.git synced 2025-04-05 11:00:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

Misc improvements

Browse source
This commit is contained in:
ccuser44 2024-12-14 21:02:09 +02:00 • committed by GitHub
parent 101187d95f
commit c09c926a34
Signed by: DevComp
GPG key ID: B5690EEEBB952194
1 changed files with 27 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
docs/table.clone-locked-metatables.md
View file

@ -7,7 +7,7 @@ Allow `table.clone` to copy tables with locked metatables.
## Motivation
As proposed by the [`table.clone` RFC](function-table-clone.md), the function `table.clone` cannot create shallow copies of a table if it has a locked metatable.
Due to this ugly limitation, it is extremely un-ergonomic to create shallow copies of arbitary tables.
Due to this ugly limitation, it is extremely un-ergonomic to create shallow copies of arbitrary tables.
The current behavior of using `table.clone` on a table with a locked metatable is a hard-fail approach where `table.clone` spits out an error instead of having a soft-fail approach wherein a clone is generated without a metatable.
This hard-fail approach severely hinders the usefulness of `table.clone` due to in practice users having to re-implement the function in many scenarios.
@ -19,18 +19,18 @@ ie. The behavior (as described by Lua pseudocode) would go from:
```lua
function table.clone(t)
assert(type(t) == "table")
local nt = {}
assert(type(t) == "table")
local nt = {}
for k, v in pairs(t) do
nt[k] =v
end
for k, v in pairs(t) do
nt[k] =v
end
if type(getmetatable(t)) == "table" then
setmetatable(nt, getmetatable(t))
end
if type(getmetatable(t)) == "table" then
setmetatable(nt, getmetatable(t))
end
return nt
return nt
end
```
@ -38,32 +38,37 @@ to:
```lua
function table.clone(t)
assert(type(t) == "table")
local nt = {}
assert(type(t) == "table")
local nt = {}
for k, v in pairs(t) do
nt[k] =v
end
for k, v in pairs(t) do
nt[k] =v
end
local mtLocked = getmetatable(t) ~= nil and not pcall(setmetatable, t, getmetatable(t))
local mtLocked = getmetatable(t) ~= nil and not pcall(setmetatable, t, getmetatable(t))
if not mtLocked and type(getmetatable(t)) == "table" then
setmetatable(nt, getmetatable(t))
end
if not mtLocked and type(getmetatable(t)) == "table" then
setmetatable(nt, getmetatable(t))
end
return nt
return nt
end
```
## Drawbacks
There are no drawbacks to this.
The original RFC puts forth a rationale for restricting cloning tables with locked metatables due to security reasons.
This is a valid concern. The issue at hand being an avenue to assign metatables to unintended tables.
However, this is not a concern as the changes proposed in this RFC do not allow such behavior.
However, this is not an issue as the changes proposed in this RFC do not allow for such behavior.
Another potential drawback that could be levied at this proposal is a reduced debuggability of not hard-failing when the expected behavior would be to create a shallow copy with the metatable of the original table.
However, this point is most certainly moot in practice, as most users very likely are not even aware, or desire the fact that `table.clone` can assign the metatables of the original table to the clone.
<!-- This was the point about the dictionary definition of shallow copying made in the original RFC -->
## Alternatives
An alternate mode of action would be to also clone the locked metatable to the new copy.
This would, however, come with a few downsides, including potential security and usability issues, as pointed out in the original RFC.
This approach is less flexible than the one proposed in this RFC as users couldn't define custom metatables for shallow copies and has no practical benefits that do not violate security guarantees.
This approach is also less flexible than the one proposed in this RFC as users couldn't create shallow copies without metatables at all and has no practical benefits that do not violate security guarantees.