Typemaker 1.1 rebased - fixes and improvements

Content.Tests/DMProject/Tests/Typemaker/arg_implicit_null2.dm

@@ -4,3 +4,4 @@
 
 /proc/RunTest()
 	return
+#pragma ImplicitNullType notice

DMCompiler/Compiler/DM/AST/DMAST.ObjectStatements.cs

@@ -61,7 +61,7 @@ public sealed class DMASTObjectVarDefinition(
     Location location,
     DreamPath path,
     DMASTExpression value,
-    DMComplexValueType valType,
+    DMComplexValueType? valType,
     DreamPath? valPath = null) : DMASTStatement(location) {
     /// <summary>The path of the object that we are a property of.</summary>
     public DreamPath ObjectPath => _varDecl.ObjectPath;
@@ -80,7 +80,7 @@ public sealed class DMASTObjectVarDefinition(
     public bool IsFinal => _varDecl.IsFinal;
     public bool IsTmp => _varDecl.IsTmp;
 
-    public readonly DMComplexValueType ValType = valType;
+    public readonly DMComplexValueType? ValType = valType;
 }
 
 public sealed class DMASTMultipleObjectVarDefinitions(Location location, DMASTObjectVarDefinition[] varDefinitions)

DMCompiler/Compiler/DM/AST/DMAST.ProcStatements.cs

@@ -29,13 +29,14 @@ public sealed class DMASTProcStatementExpression(Location location, DMASTExpress
     public DMASTExpression Expression = expression;
 }
 
-public sealed class DMASTProcStatementVarDeclaration(Location location, DMASTPath path, DMASTExpression? value, DMComplexValueType valType)
+public sealed class DMASTProcStatementVarDeclaration(Location location, DMASTPath path, DMASTExpression? value, DMComplexValueType? valType)
     : DMASTProcStatement(location) {
     public DMASTExpression? Value = value;
 
     public DreamPath? Type => _varDecl.IsList ? DreamPath.List : _varDecl.TypePath;
+    public DMComplexValueType? ExplicitValType => valType;
 
-    public DMComplexValueType ValType => valType;
+    public DMComplexValueType ValType => ExplicitValType ?? DMValueType.Anything;
 
     public string Name => _varDecl.VarName;
     public bool IsGlobal => _varDecl.IsStatic;

DMCompiler/DM/Builders/DMExpressionBuilder.cs

@@ -46,6 +46,11 @@ public void Emit(DMASTExpression expression, DreamPath? inferredPath = null) {
         expr.EmitPushValue(ctx);
     }
 
+    public void Emit(DMASTExpression expression, out DMExpression returnedExpr, DreamPath? inferredPath = null) {
+        returnedExpr = Create(expression, inferredPath);
+        returnedExpr.EmitPushValue(ctx);
+    }
+
     public bool TryConstant(DMASTExpression expression, out Constant? constant) {
         var expr = Create(expression);
         return expr.TryAsConstant(Compiler, out constant);
@@ -64,7 +69,7 @@ private DMExpression BuildExpression(DMASTExpression expression, DreamPath? infe
             case DMASTStringFormat stringFormat: result = BuildStringFormat(stringFormat, inferredPath); break;
             case DMASTIdentifier identifier: result = BuildIdentifier(identifier, inferredPath); break;
             case DMASTScopeIdentifier globalIdentifier: result = BuildScopeIdentifier(globalIdentifier, inferredPath); break;
-            case DMASTCallableSelf: result = new ProcSelf(expression.Location, ctx.Proc.ReturnTypes); break;
+            case DMASTCallableSelf: result = new ProcSelf(expression.Location, ctx.Proc.RawReturnTypes); break;
             case DMASTCallableSuper: result = new ProcSuper(expression.Location, ctx.Type.GetProcReturnTypes(ctx.Proc.Name)); break;
             case DMASTCallableProcIdentifier procIdentifier: result = BuildCallableProcIdentifier(procIdentifier, ctx.Type); break;
             case DMASTProcCall procCall: result = BuildProcCall(procCall, inferredPath); break;
@@ -272,10 +277,10 @@ private DMExpression BuildExpression(DMASTExpression expression, DreamPath? infe
 
                 if (b.ValType.TypePath != null && c.ValType.TypePath != null && b.ValType.TypePath != c.ValType.TypePath) {
                     Compiler.Emit(WarningCode.LostTypeInfo, ternary.Location,
-                        $"Ternary has type paths {b.ValType.TypePath} and {c.ValType.TypePath} but a value can only have one type path. Using {b.ValType.TypePath}.");
+                        $"Ternary has type paths {b.ValType.TypePath} and {c.ValType.TypePath} but a value can only have one type path. Using their common ancestor, {b.ValType.TypePath.Value.GetLastCommonAncestor(Compiler, c.ValType.TypePath.Value)}.");
                 }
 
-                result = new Ternary(ternary.Location, a, b, c);
+                result = new Ternary(Compiler, ternary.Location, a, b, c);
                 break;
             case DMASTNewPath newPath:
                 if (BuildExpression(newPath.Path, inferredPath) is not IConstantPath path) {
@@ -284,11 +289,11 @@ private DMExpression BuildExpression(DMASTExpression expression, DreamPath? infe
                     break;
                 }
 
-                result = new NewPath(Compiler, newPath.Location, path,
+                result = new NewPath(newPath.Location, path,
                     BuildArgumentList(newPath.Location, newPath.Parameters, inferredPath));
                 break;
             case DMASTNewExpr newExpr:
-                result = new New(Compiler, newExpr.Location,
+                result = new New(newExpr.Location,
                     BuildExpression(newExpr.Expression, inferredPath),
                     BuildArgumentList(newExpr.Location, newExpr.Parameters, inferredPath));
                 break;
@@ -305,7 +310,7 @@ private DMExpression BuildExpression(DMASTExpression expression, DreamPath? infe
                     break;
                 }
 
-                result = new NewPath(Compiler, newInferred.Location, inferredType,
+                result = new NewPath(newInferred.Location, inferredType,
                     BuildArgumentList(newInferred.Location, newInferred.Parameters, inferredPath));
                 break;
             case DMASTPreIncrement preIncrement:
@@ -581,7 +586,7 @@ private DMExpression BuildIdentifier(DMASTIdentifier identifier, DreamPath? infe
                 if (scopeMode == Normal) {
                     var localVar = ctx.Proc?.GetLocalVariable(name);
                     if (localVar != null)
-                        return new Local(identifier.Location, localVar);
+                        return new Local(identifier.Location, localVar, localVar.ExplicitValueType);
                 }
 
                 var field = ctx.Type.GetVariable(name);
@@ -615,7 +620,7 @@ private DMExpression BuildScopeIdentifier(DMASTScopeIdentifier scopeIdentifier,
                     return UnknownReference(location, $"No global proc named \"{bIdentifier}\" exists");
 
                 var arguments = BuildArgumentList(location, scopeIdentifier.CallArguments, inferredPath);
-                return new ProcCall(location, new GlobalProc(location, globalProc), arguments, DMValueType.Anything);
+                return new ProcCall(Compiler, location, new GlobalProc(location, globalProc), arguments, DMValueType.Anything);
             }
 
             // ::vars, special case
@@ -701,7 +706,7 @@ private DMExpression BuildScopeIdentifier(DMASTScopeIdentifier scopeIdentifier,
             if (variable == null)
                 return UnknownIdentifier(location, bIdentifier);
 
-            return new ScopeReference(ObjectTree, location, expression, bIdentifier, variable);
+            return new ScopeReference(Compiler, location, expression, bIdentifier, variable);
         }
     }
 
@@ -715,7 +720,7 @@ private DMExpression BuildCallableProcIdentifier(DMASTCallableProcIdentifier pro
         }
 
         if (dmObject.HasProc(procIdentifier.Identifier)) {
-            return new Proc(procIdentifier.Location, procIdentifier.Identifier);
+            return new Proc(procIdentifier.Location, procIdentifier.Identifier, dmObject);
         }
 
         if (ObjectTree.TryGetGlobalProc(procIdentifier.Identifier, out var globalProc)) {
@@ -752,10 +757,10 @@ private DMExpression BuildProcCall(DMASTProcCall procCall, DreamPath? inferredPa
         if (target is Proc targetProc) { // GlobalProc handles returnType itself
             var returnType = targetProc.GetReturnType(ctx.Type);
 
-            return new ProcCall(procCall.Location, target, args, returnType);
+            return new ProcCall(Compiler, procCall.Location, target, args, returnType);
         }
 
-        return new ProcCall(procCall.Location, target, args, DMValueType.Anything);
+        return new ProcCall(Compiler, procCall.Location, target, args, DMValueType.Anything);
     }
 
     private ArgumentList BuildArgumentList(Location location, DMASTCallParameter[]? arguments, DreamPath? inferredPath = null) {
@@ -885,7 +890,7 @@ private DMExpression BuildDereference(DMASTDereference deref, DreamPath? inferre
                         var argumentList = BuildArgumentList(deref.Expression.Location, callOperation.Parameters, inferredPath);
 
                         var globalProcExpr = new GlobalProc(expr.Location, globalProc);
-                        expr = new ProcCall(expr.Location, globalProcExpr, argumentList, DMValueType.Anything);
+                        expr = new ProcCall(Compiler, expr.Location, globalProcExpr, argumentList, DMValueType.Anything);
                         break;
 
                     case DMASTDereference.FieldOperation:
@@ -1021,6 +1026,7 @@ private DMExpression BuildDereference(DMASTDereference deref, DreamPath? inferre
                 case DMASTDereference.CallOperation callOperation: {
                     var field = callOperation.Identifier;
                     var argumentList = BuildArgumentList(deref.Expression.Location, callOperation.Parameters, inferredPath);
+                    DreamPath? nextPath = null;
 
                     if (!callOperation.NoSearch && !pathIsFuzzy) {
                         if (prevPath == null) {
@@ -1031,16 +1037,25 @@ private DMExpression BuildDereference(DMASTDereference deref, DreamPath? inferre
                             return UnknownReference(callOperation.Location, $"Type {prevPath.Value} does not exist");
                         if (!fromObject.HasProc(field))
                             return UnknownIdentifier(callOperation.Location, field);
+
+                        var returnTypes = fromObject.GetProcReturnTypes(field, argumentList) ?? DMValueType.Anything;
+                        nextPath = returnTypes.HasPath ? returnTypes.TypePath : returnTypes.AsPath();
+                        if (!returnTypes.HasPath & nextPath.HasValue) {
+                            var thePath = nextPath!.Value;
+                            thePath.Type = DreamPath.PathType.UpwardSearch;
+                            nextPath = thePath;
+                        }
                     }
 
                     operation = new Dereference.CallOperation {
                         Parameters = argumentList,
                         Safe = callOperation.Safe,
                         Identifier = field,
-                        Path = null
+                        Path = prevPath
                     };
-                    prevPath = null;
-                    pathIsFuzzy = true;
+                    prevPath = nextPath;
+                    if(prevPath is null)
+                        pathIsFuzzy = true;
                     break;
                 }
 
@@ -1062,7 +1077,7 @@ private DMExpression BuildLocate(DMASTLocate locate, DreamPath? inferredPath) {
             if (inferredPath == null)
                 return BadExpression(WarningCode.BadExpression, locate.Location, "inferred locate requires a type");
 
-            return new LocateInferred(locate.Location, inferredPath.Value, container);
+            return new LocateInferred(Compiler, locate.Location, inferredPath.Value, container);
         }
 
         var pathExpr = BuildExpression(locate.Expression, inferredPath);
@@ -1103,7 +1118,7 @@ private DMExpression BuildList(DMASTList list, DreamPath? inferredPath) {
             }
         }
 
-        return new List(list.Location, values);
+        return new List(Compiler, list.Location, values);
     }
 
     private DMExpression BuildDimensionalList(DMASTDimensionalList list, DreamPath? inferredPath) {
@@ -1209,7 +1224,7 @@ private DMExpression BuildPick(DMASTPick pick, DreamPath? inferredPath) {
             pickValues[i] = new Pick.PickValue(weight, value);
         }
 
-        return new Pick(pick.Location, pickValues);
+        return new Pick(Compiler, pick.Location, pickValues);
     }
 
     private DMExpression BuildLog(DMASTLog log, DreamPath? inferredPath) {