when calling or indexing a union with nil, error and act as if the nil value doesn't exist

Author: CapsAdmin

nattlua/analyzer/expressions/postfix_call.lua

@@ -1,8 +1,45 @@
 local table = _G.table
 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
+
+	if self:IsTypesystem() then
+		if
+			#types == 1 and
+			types[1].Type == "tuple" and
+			callable:GetInputSignature():GetTupleLength() == math.huge
+		then
+			arguments = types[1]
+		else
+			arguments = Tuple(types)
+		end
+	else
+		arguments = NormalizeTuples(types)
+	end
+
+	self:PushCurrentExpression(node)
+	local ret, err = self:Call(callable, arguments, node)
+	self:PopCurrentExpression()
+
+	if not ret then
+		self:Error(err)
+
+		if callable.Type == "function" and callable:IsExplicitOutputSignature() then
+			return callable:GetOutputSignature():Copy()
+		end
+	end
+
+	return ret, err
+end
+
 return {
 	AnalyzePostfixCall = function(self, node)
 		if
@@ -13,6 +50,7 @@ return {
 			return AnalyzeImport(self, node, node.left.value.value == "require" and node.path)
 		end
 
+
 		local is_type_call = node.type_call or
 			node.left and
 			(
@@ -32,54 +70,44 @@ return {
 
 			if self:IsRuntime() then self_arg = self_arg:GetFirstValue() end
 		end
+		local returned_tuple
 
-		local types = {self_arg}
-		self:AnalyzeExpressions(node.expressions, types)
-		local arguments
+		if self_arg and self_arg.Type == "union" then
+			for _, self_arg in ipairs(self_arg:GetData()) do
+				local tup = postfix_call(self, self_arg, node, callable)
 
-		if self:IsTypesystem() then
-			if
-				#types == 1 and
-				types[1].Type == "tuple" and
-				callable:GetInputSignature():GetTupleLength() == math.huge
-			then
-				arguments = types[1]
-			else
-				arguments = Tuple(types)
+				if tup then
+					local s = tup:GetFirstValue()
+					if s and not s:IsEmpty() then
+						if returned_tuple then
+							returned_tuple:AddType(s)
+						end
+						returned_tuple = returned_tuple or Union({s})
+					end
+				end
 			end
-		else
-			arguments = NormalizeTuples(types)
 		end
 
-		self:PushCurrentExpression(node)
-		local ret, err = self:Call(callable, arguments, node)
-		self:PopCurrentExpression()
-		local returned_tuple
-
-		if not ret then
-			self:Error(err)
-
-			if callable.Type == "function" and callable:IsExplicitOutputSignature() then
-				returned_tuple = callable:GetOutputSignature():Copy()
-			else
-				returned_tuple = Tuple({Nil()})
+		if not returned_tuple then
+			local val, err = postfix_call(self, self_arg, node, callable)
+			if not val then
+				return val, err
 			end
-		else
-			returned_tuple = ret
+			returned_tuple = val
 		end
+		self:PopAnalyzerEnvironment()
 
 		-- TUPLE UNPACK MESS
 		if node.tokens["("] and node.tokens[")"] and returned_tuple.Type == "tuple" then
 			returned_tuple = returned_tuple:GetWithNumber(1)
 		end
 
 		if self:IsTypesystem() then
-			if returned_tuple.Type == "tuple" and returned_tuple:HasOneValue() then
+			if returned_tuple and returned_tuple.Type == "tuple" and returned_tuple:HasOneValue() then
 				returned_tuple = returned_tuple:GetWithNumber(1)
 			end
 		end
 
-		self:PopAnalyzerEnvironment()
 		return returned_tuple
 	end,
 }

nattlua/analyzer/operators/call.lua

@@ -81,17 +81,19 @@ local function union_call(self, analyzer, input, call_node)
 			if recursively_called then return recursively_called end
 		end
 
-		local ok, err = analyzer:Call(obj, input:Copy(), call_node, true)
-		local val = analyzer:Assert(ok, err)
-
-		-- TODO
-		if val.Type == "tuple" and val:HasOneValue() then
-			val = val:Unpack(1)
-		elseif val.Type == "union" and val:GetMinimumLength() == 1 then
-			val = val:GetAtTupleIndex(1)
-		end
+		local val, err = analyzer:Call(obj, input:Copy(), call_node, true)
+
+		if not val then
+			analyzer:Error(err)
+		else
+			if val.Type == "tuple" and val:HasOneValue() then
+				val = val:Unpack(1)
+			elseif val.Type == "union" and val:GetMinimumLength() == 1 then
+				val = val:GetAtTupleIndex(1)
+			end
 
-		new:AddType(val)
+			new:AddType(val)
+		end
 
 		if obj.Type == "function" then analyzer:PopCallFrame() end
 	end

nattlua/analyzer/operators/index.lua

@@ -135,9 +135,8 @@ local function index_union(analyzer, obj, key)
 		else
 			local val, err = analyzer:IndexOperator(obj, key)
 
-			if not val then return val, err end
 
-			union:AddType(val)
+			if not val then analyzer:Error(err) else union:AddType(val) end
 		end
 	end
 

nattlua/definitions/lua/globals.nlua

@@ -4,7 +4,7 @@ type _ = any
 type @Name = "_G"
 type rawlen = function=(v: Table | string)>(number)
 type rawequal = function=(v1: any, v2: any)>(boolean)
-type collectgarbage = function=(opt: string, arg: number)>(...) | function=(opt: string)>(...) | function=()>(...)
+type collectgarbage = function=(opt: string, arg: number)>(...: any) | function=(opt: string)>(...: any) | function=()>(...: any)
 
 analyzer function type_print(...: ...any)
 	print(...)

test/tests/nattlua/analyzer/analyzer.lua

@@ -706,3 +706,31 @@ attest.equal(-x, 42)
 attest.equal(~x, 43)
 attest.equal(#x, 44)
 ]]
+analyze[[
+local x = _ as nil | function=()>(1)
+attest.expect_diagnostic<|"error", "uncallable object nil"|>
+local res = x()
+attest.equal(res, 1)
+]]
+analyze[[
+
+local x = _ as {foo = nil | function=()>(1)}
+attest.expect_diagnostic<|"error", "uncallable object nil"|>
+local res = x.foo()
+attest.equal(res, 1)
+
+]]
+analyze[[
+
+local x = _ as {foo = nil | function=(self: self)>(1)}
+attest.expect_diagnostic<|"error", "uncallable object nil"|>
+local res = x:foo()
+attest.equal(res, 1)
+]]
+analyze[[
+local x = io.popen("")
+attest.expect_diagnostic("error", "nil is not a subset of")
+attest.expect_diagnostic("error", "on type symbol")
+local y = x:read("*all")
+attest.equal(y, _ as nil | string)
+]]