experimental optimization 2

Author: CapsAdmin

nattlua/analyzer/operators/function_call_body.lua

@@ -32,6 +32,44 @@ local function restore_mutated_types(self)
 	table_clear(env.mutated_types)
 end
 
+local function can_wrap_table_argument(contract)
+	if contract.Type == "table" then return true end
+
+	if contract.Type ~= "union" then return false end
+
+	for _, obj in ipairs(contract:GetData()) do
+		if obj.Type ~= "table" and (obj.Type ~= "symbol" or not obj:IsNil()) then
+			return false
+		end
+	end
+
+	return true
+end
+
+local function get_argument_value(arg, contract)
+	if
+		arg and
+		arg.Type == "table" and
+		can_wrap_table_argument(contract) and
+		not arg:GetMetaTable()
+		and
+		not arg:GetTypeOverride()
+		and
+		not arg:GetName()
+		and
+		not arg:IsUnique()
+	then
+		local tbl = Table()
+		tbl:SetContract(contract)
+		tbl:SetAnalyzerEnvironment(arg:GetAnalyzerEnvironment())
+		return tbl
+	end
+
+	local val = contract:GetFirstValue():Copy(nil, true)
+	val:SetContract(contract)
+	return val
+end
+
 local function shrink_union_to_function_signature(obj)
 	local arg = Tuple()
 	local ret = Tuple()
@@ -314,9 +352,7 @@ return function(self, obj, input)
 						test<|number|>(1)
 					]]
 					-- if it's a ref argument we pass the incoming value
-					local t = contract:GetFirstValue():Copy(nil, true)
-					t:SetContract(contract)
-					input:Set(i, t)
+					input:Set(i, get_argument_value(arg, contract))
 				end
 			elseif
 				arg and
@@ -337,15 +373,11 @@ return function(self, obj, input)
 
 				if doit then
 					-- if it's not a ref argument we pass the incoming value
-					local t = contract:GetFirstValue():Copy(nil, true)
-					t:SetContract(contract)
-					input:Set(i, t)
+					input:Set(i, get_argument_value(arg, contract))
 				end
 			else
 				if arg.Type == "any" and arg.Type ~= contract.Type then
-					local t = contract:GetFirstValue():Copy(nil, true)
-					t:SetContract(contract)
-					input:Set(i, t)
+					input:Set(i, get_argument_value(arg, contract))
 				end
 			end
 		end

nattlua/types/shared.lua

@@ -308,6 +308,18 @@ function shared.IsSubsetOf(
 
 		if b.Type == "any" then return true, "b is any" end
 
+		do
+			local contract = a:GetContract()
+
+			if contract and contract ~= a then
+				if contract == b then return true, "same contract" end
+
+				local ok, err = shared.IsSubsetOf(contract, b, visited, max_length)
+
+				if ok then return true, "contract is subset" end
+			end
+		end
+
 		if b.Type == "table" then
 			if a == b then return true, "same type" end
 

nattlua/types/union.lua

@@ -466,7 +466,6 @@ end
 
 function META:Copy(map--[[#: Map<|any, any|> | nil]], copy_tables--[[#: nil | boolean]])--[[#: TUnion]]
 	map = map or {}
-
 	local existing = map[self]
 
 	if existing then return existing--[[# as TUnion]] end -- TODO map[self] doesn't make return map[self] not nil
@@ -483,7 +482,8 @@ function META:Copy(map--[[#: Map<|any, any|> | nil]], copy_tables--[[#: nil | bo
 		if mapped then
 			obj = mapped
 		elseif obj.Type == "table" and not copy_tables then
-			-- keep shared table references when the caller explicitly asked for it
+
+		-- keep shared table references when the caller explicitly asked for it
 		else
 			map[obj] = obj:Copy(map, copy_tables)
 			obj = map[obj]
@@ -502,10 +502,10 @@ end
 
 function META:CopyForReturn(map--[[#: Map<|any, any|> | nil]])--[[#: TUnion]]
 	map = map or {}
-
 	local existing = map[self]
 
 	if existing then return existing--[[# as TUnion]] end
+
 	local copy = META.New()
 	map[self] = copy
 	local data = copy.Data
@@ -524,11 +524,7 @@ function META:CopyForReturn(map--[[#: Map<|any, any|> | nil]])--[[#: TUnion]]
 		then
 			local mapped = map[obj]
 
-			if mapped then
-				obj = mapped
-			else
-				obj = obj:CopyForReturn(map)
-			end
+			if mapped then obj = mapped else obj = obj:CopyForReturn(map) end
 		end
 
 		local s = hash(obj)
@@ -630,6 +626,25 @@ function META:IsNumeric()
 	return true
 end
 
+function META:Get(key)
+	local union = META.New()
+	local errors = {}
+
+	for _, obj in ipairs(self.Data) do
+		if obj.Type == "table" and obj:IsEmpty() then
+
+		else
+			local val, err = obj:Get(key)
+
+			if val then union:AddType(val) else table.insert(errors, err) end
+		end
+	end
+
+	if union:GetCardinality() == 0 then return false, errors end
+
+	return union:Simplify()
+end
+
 return {
 	TUnion = TUnion,
 	Union = META.New,

test/tests/nattlua/analyzer/function.lua

@@ -1021,7 +1021,7 @@ local x = {1, 2}
 local type AnyTable = {[any] = any} | {}
 
 local function foo(x: AnyTable)
-	attest.strict_equal(x, _ as {[any] = any} | {})
+    attest.equal(x[1], _ as any)
 	x[1]= 1
 end
 

test/tests/nattlua/analyzer/generics.lua

@@ -104,24 +104,24 @@ analyze[[
     local function Array<|T: any, Size: number|>(init: nil | {[Size] = T})
         attest.equal<|T, string|>
         attest.equal<|Size, 1..10|>
-        attest.equal(init, _ as nil | {[Size] = T})
+        attest.subset_of(init, _ as nil | {[Size] = T})
         return init
     end
     
     local arr = Array<|string, 1..10|>({"hello", "world"})
-    attest.equal(arr, _ as nil | {[1..10] = string})    
+    attest.subset_of(arr, _ as nil | {[1..10] = string})
 ]]
 analyze[[
     local function Array<|T: any, Size: number|>(init: nil | {[Size] = T})
         attest.equal<|T, string|>
         attest.equal<|Size, 1..10|>
-        attest.equal(init, _ as nil | {[Size] = T})
+        attest.subset_of(init, _ as nil | {[Size] = T})
         return init
     end
     
     do
         local arr = Array<|string, 1..10|>({"hello", "world"})
-        attest.equal(arr, _ as nil | {[1..10] = string})    
+        attest.subset_of(arr, _ as nil | {[1..10] = string})
     end
 ]]
 analyze[[