optimizations

Author: CapsAdmin

nattlua/analyzer/expressions/postfix_call.lua

@@ -1,31 +1,78 @@
 local table = _G.table
 local math_huge = _G.math.huge
 local ipairs = _G.ipairs
-local NormalizeTuples = require("nattlua.types.tuple").NormalizeTuples
 local Union = require("nattlua.types.union").Union
 local Tuple = require("nattlua.types.tuple").Tuple
 local Nil = require("nattlua.types.symbol").Nil
 local AnalyzeImport = require("nattlua.analyzer.expressions.import").AnalyzeImport
 
-local function postfix_call(self, self_arg, node, callable)
-	local types = {self_arg}
-	self:AnalyzeExpressions(node.expressions, types)
-	local arguments
+local function normalize_tuples(self, callable, types)
+	local is_typesystem = self:IsTypesystem()
 
-	if self:IsTypesystem() then
-		if
-			#types == 1 and
-			types[1].Type == "tuple" and
+	if
+		#types == 1 and
+		types[1].Type == "tuple" and
+		(
+			not is_typesystem or
 			callable:GetInputSignature():GetTupleLength() == math_huge
-		then
-			arguments = types[1]
+		)
+	then
+		return types[1]
+	end
+
+	if is_typesystem then return Tuple(types) end
+
+	local temp = {}
+	local temp_i = 1
+
+	for i, v in ipairs(types) do
+		if v.Type == "tuple" then
+			if i == #types then
+				temp[temp_i] = v
+				temp_i = temp_i + 1
+			else
+				local obj = v:GetWithNumber(1)
+
+				if obj then
+					temp[temp_i] = obj
+					temp_i = temp_i + 1
+				end
+			end
 		else
-			arguments = Tuple(types)
+			temp[temp_i] = v
+			temp_i = temp_i + 1
 		end
-	else
-		arguments = NormalizeTuples(types)
 	end
 
+	if #temp == 1 and temp[1].Type ~= "tuple" and temp[1].Type ~= "union" then
+		return Tuple({temp[1]})
+	end
+
+	local arguments = Tuple(temp)
+	temp = {}
+
+	for i = 1, 128 do
+		local v, is_inf = arguments:GetAtTupleIndex(i)
+
+		if v and v.Type == "tuple" or is_inf then
+			-- inf tuple
+			temp[i] = v or Any()
+
+			break
+		end
+
+		if not v then break end
+
+		temp[i] = v
+	end
+
+	return Tuple(temp)
+end
+
+local function postfix_call(self, self_arg, node, callable)
+	local types = {self_arg}
+	self:AnalyzeExpressions(node.expressions, types)
+	local arguments = normalize_tuples(self, callable, types)
 	self:PushCurrentExpression(node)
 	local ret, err = self:Call(callable, arguments, node)
 	self:PopCurrentExpression()

nattlua/analyzer/operators/function_call_body.lua

@@ -485,23 +485,32 @@ return function(self, obj, input)
 	local output
 
 	do
-		local union = Union()
+		local union = {}
 
-		for _, ret in ipairs(returns) do
+		for i, ret in ipairs(returns) do
 			if #ret.types == 1 then
-				union:AddType(ret.types[1])
+				union[i] = ret.types[1]
 			elseif #ret.types == 0 then
-				local tup = Tuple({Nil()})
-				union:AddType(tup)
+				union[i] = Nil()
 			else
-				local tup = Tuple(ret.types)
-				union:AddType(tup)
+				union[i] = Tuple(ret.types)
 			end
 		end
-
-		output = union:Simplify()
-
-		if output.Type ~= "tuple" then output = Tuple({output}) end
+		
+		if #union == 1 then
+			if union[1].Type == "tuple" then
+				output = union[1]
+			elseif union[1].Type == "union" then
+				output = union[1]
+				output = output:Simplify()
+				if output.Type ~= "tuple" then output = Tuple({output}) end
+			else
+				output = Tuple({union[1]})
+			end
+		else
+			output = Union(union):Simplify()
+			if output.Type ~= "tuple" then output = Tuple({output}) end
+		end
 	end
 
 	if not obj:IsExplicitOutputSignature() then

nattlua/analyzer/statements/generic_for.lua

@@ -1,7 +1,6 @@
 local table = _G.table
 local ipairs = ipairs
 local Tuple = require("nattlua.types.tuple").Tuple
-local NormalizeTuples = require("nattlua.types.tuple").NormalizeTuples
 local Union = require("nattlua.types.union").Union
 local Nil = require("nattlua.types.symbol").Nil
 local type_errors = require("nattlua.types.error_messages")

nattlua/types/tuple.lua

@@ -303,9 +303,7 @@ function META.IsNotSubsetOfTuple(a--[[#: TTuple]], b--[[#: TTuple]])
 	for i = 1, math.max(a:GetMinimumLength2(), b:GetMinimumLength2()) do
 		local ok, reason, a_val, b_val, offset = a.IsSubsetOfTupleAtIndex(a, b, i)
 
-		if not ok then
-			table.insert(errors, {reason, a_val, b_val, offset})
-		end
+		if not ok then table.insert(errors, {reason, a_val, b_val, offset}) end
 	end
 
 	return errors[1] and errors or nil
@@ -746,9 +744,7 @@ function META.New(data--[[#: nil | List<|TBaseType|>]])
 		}
 	)
 
-	if data and data[1] then 
-		self:SetTable(data)
-	end
+	if data and data[1] then self:SetTable(data) end
 
 	return self
 end
@@ -760,50 +756,4 @@ return {
 		self:SetRepeat(math.huge)
 		return self
 	end,
-	NormalizeTuples = function(types--[[#: List<|TBaseType|>]])
-		local arguments
-
-		if #types == 1 and types[1] and types[1].Type == "tuple" then
-			arguments = types[1]
-		else
-			local temp = {}
-
-			for i, v in ipairs(types) do
-				if v.Type == "tuple" then
-					if i == #types then
-						table.insert(temp, v)
-					else
-						local obj = v:GetWithNumber(1)
-
-						if obj then table.insert(temp, obj) end
-					end
-				else
-					table.insert(temp, v)
-				end
-			end
-
-			local old_temp = temp
-			arguments = META.New(temp)
-			local temp = {}
-
-			for i = 1, 128 do
-				local v, is_inf = arguments:GetAtTupleIndex(i)
-
-				if v and v.Type == "tuple" or is_inf then
-					-- inf tuple
-					temp[i] = v or Any()
-
-					break
-				end
-
-				if not v then break end
-
-				temp[i] = v
-			end
-
-			arguments = META.New(temp)
-		end
-
-		return arguments
-	end,
 }