Optimize Lua type assurance boundaries

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/attributes/AttrExprExpectedType.java

@@ -2,6 +2,7 @@
 
 import de.peeeq.wurstscript.WLogger;
 import de.peeeq.wurstscript.ast.*;
+import de.peeeq.wurstscript.attributes.names.FuncLink;
 import de.peeeq.wurstscript.types.*;
 import de.peeeq.wurstscript.utils.Utils;
 import org.eclipse.jdt.annotation.NonNull;
@@ -46,6 +47,14 @@ public class AttrExprExpectedType {
                 return varDef.attrTyp();
             } else if (parent instanceof ExprBinary) {
                 ExprBinary exprBinary = (ExprBinary) parent;
+                if (exprBinary.attrFuncLink() != null) {
+                    FunctionSignature signature = FunctionSignature.fromNameLink(exprBinary.attrFuncLink());
+                    if (exprBinary.getLeft() == expr && signature.getReceiverType() != null) {
+                        return signature.getReceiverType();
+                    } else if (exprBinary.getRight() == expr && !signature.getParamTypes().isEmpty()) {
+                        return signature.getParamType(0);
+                    }
+                }
                 WurstType leftType = exprBinary.getLeft().attrTyp();
                 WurstType rightType = exprBinary.getRight().attrTyp();
                 if (leftType.equalsType(rightType, expr)) {
@@ -72,10 +81,44 @@ public class AttrExprExpectedType {
                 }
             } else if (parent instanceof StmtReturn) {
                 StmtReturn stmtReturn = (StmtReturn) parent;
+                if (stmtReturn.getParent() instanceof ExprStatementsBlock) {
+                    ExprStatementsBlock block = (ExprStatementsBlock) stmtReturn.getParent();
+                    WurstType expectedType = block.attrExpectedTypRaw();
+                    if (expectedType instanceof WurstTypeUnknown
+                        && block.getParent() instanceof ExprClosure) {
+                        FuncLink abstractMethod = ((ExprClosure) block.getParent()).attrClosureAbstractMethod();
+                        if (abstractMethod != null) {
+                            return abstractMethod.getReturnType();
+                        }
+                    }
+                    return expectedType;
+                }
                 FunctionImplementation nearestFuncDef = stmtReturn.attrNearestFuncDef();
                 if (nearestFuncDef != null) {
                     return nearestFuncDef.attrReturnTyp();
                 }
+            } else if (parent instanceof StmtForRange) {
+                StmtForRange forRange = (StmtForRange) parent;
+                if (forRange.getTo() == expr || forRange.getStep() == expr) {
+                    return WurstTypeInt.instance();
+                }
+            } else if (parent instanceof ExprStatementsBlock) {
+                ExprStatementsBlock block = (ExprStatementsBlock) parent;
+                if (block.getReturnStmt() != null && block.getReturnStmt().getReturnedObj() == expr) {
+                    return block.attrExpectedTypRaw();
+                }
+            } else if (parent instanceof Indexes) {
+                return WurstTypeInt.instance();
+            } else if (parent instanceof SwitchStmt) {
+                SwitchStmt switchStmt = (SwitchStmt) parent;
+                if (switchStmt.getExpr() == expr) {
+                    for (SwitchCase switchCase : switchStmt.getCases()) {
+                        for (Expr caseExpr : switchCase.getExpressions()) {
+                            WurstType type = caseExpr.attrTyp();
+                            return type instanceof WurstTypeIntLiteral ? WurstTypeInt.instance() : type;
+                        }
+                    }
+                }
             } else if (parent instanceof SwitchCase) {
                 SwitchCase sc = (SwitchCase) parent;
                 SwitchStmt s = (SwitchStmt) sc.getParent().getParent();
@@ -110,6 +153,14 @@ public class AttrExprExpectedType {
 
     private static WurstType expectedTypeSuperCall(SuperConstructorCall sc, Expr expr) {
         ConstructorDef constr = (ConstructorDef) sc.getParent();
+        int paramIndex = SmallHelpers.superArgs(constr).indexOf(expr);
+        ConstructorDef selected = constr.attrSuperConstructor();
+        if (selected != null) {
+            WurstType selectedType = constructorParameterType(selected, paramIndex);
+            if (!(selectedType instanceof WurstTypeUnknown)) {
+                return selectedType;
+            }
+        }
         ClassDef c = constr.attrNearestClassDef();
         if (c == null) {
             return WurstTypeUnknown.instance();
@@ -125,8 +176,6 @@ private static WurstType expectedTypeSuperCall(SuperConstructorCall sc, Expr exp
 
         WurstType res = WurstTypeUnknown.instance();
 
-        int paramIndex = SmallHelpers.superArgs(constr).indexOf(expr);
-
         for (ConstructorDef superConstr : constructors) {
             if (superConstr.getParameters().size() == SmallHelpers.superArgs(constr).size()) {
                 res = res.typeUnion(superConstr.getParameters().get(paramIndex).getTyp().attrTyp(), expr);
@@ -136,6 +185,19 @@ private static WurstType expectedTypeSuperCall(SuperConstructorCall sc, Expr exp
         return res;
     }
 
+    public static WurstType constructorParameterType(ConstructorDef constructor, int argumentIndex) {
+        if (argumentIndex < 0 || constructor.getParameters().isEmpty()) {
+            return WurstTypeUnknown.instance();
+        }
+        int lastParameterIndex = constructor.getParameters().size() - 1;
+        WurstType parameterType = constructor.getParameters()
+            .get(Math.min(argumentIndex, lastParameterIndex)).attrTyp();
+        if (argumentIndex >= lastParameterIndex && parameterType instanceof WurstTypeVararg) {
+            return ((WurstTypeVararg) parameterType).getBaseType();
+        }
+        return argumentIndex <= lastParameterIndex ? parameterType : WurstTypeUnknown.instance();
+    }
+
     private static WurstType expectedType(Expr expr, Arguments args, StmtCall stmtCall) {
         Collection<FunctionSignature> sigs = stmtCall.attrPossibleFunctionSignatures();
 

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/ClassTranslator.java

@@ -2,6 +2,7 @@
 
 import de.peeeq.wurstscript.ast.*;
 import de.peeeq.wurstscript.ast.Element;
+import de.peeeq.wurstscript.attributes.AttrExprExpectedType;
 import de.peeeq.wurstscript.attributes.OverloadingResolver;
 import de.peeeq.wurstscript.jassIm.Element.DefaultVisitor;
 import de.peeeq.wurstscript.jassIm.*;
@@ -400,8 +401,11 @@ private void createConstructFunc(ConstructorDef constr) {
             if (calledConstr != null && calledConstr != constr) {
                 ImFunction calledConstrFunc = translator.getConstructFunc(calledConstr);
                 ImExprs arguments = ImExprs(ImVarAccess(thisVar));
-                for (Expr a : thisCall.getArgs()) {
-                    arguments.add(a.imTranslateExpr(translator, f));
+                for (int i = 0; i < thisCall.getArgs().size(); i++) {
+                    Expr argument = thisCall.getArgs().get(i);
+                    WurstType expectedType = AttrExprExpectedType.constructorParameterType(calledConstr, i);
+                    arguments.add(ExprTranslation.translateWithExpectedType(
+                        argument, translator, f, expectedType));
                 }
                 f.getBody().add(ImFunctionCall(trace, calledConstrFunc, classTypeArgs(), arguments, false, CallType.NORMAL));
                 bodyStartIndex = firstRelevantIndex + 1;

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imtranslation/ClosureTranslator.java

@@ -201,7 +201,16 @@ private ImClass createClass() {
         OverrideUtils.addOverrideClosure(tr, superMethod, m, e);
 
 
-        ImExpr translated = e.getImplementation().imTranslateExpr(tr, impl);
+        ImExpr translated;
+        boolean propagatesExpectedType = ExprTranslation.isCompositeExpectedTypeExpression(e.getImplementation());
+        if (propagatesExpectedType) {
+            translated = ExprTranslation.translateWithExpectedType(
+                e.getImplementation(), tr, impl, superMethod.attrReturnType());
+        } else {
+            translated = e.getImplementation().imTranslateExpr(tr, impl);
+            translated = ExprTranslation.wrapTranslation(e.getImplementation(), tr, translated,
+                e.getImplementation().attrTypRaw(), superMethod.attrReturnType());
+        }
 
 
         if (e.getImplementation().attrTyp().isVoid()) {