Fix erased operands in Lua composite expressions

Author: Frotty

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

@@ -212,6 +212,14 @@ public static ImExpr translateIntern(ExprBinary e, ImTranslator t, ImFunction f)
         FuncLink overloadedOperator = e.attrFuncLink();
         ImExpr left = translateConcatOperand(e, e.getLeft(), t, f, overloadedOperator);
         ImExpr right = translateConcatOperand(e, e.getRight(), t, f, overloadedOperator);
+        if (overloadedOperator == null) {
+            // A built-in operator can leave both operands with the same erased
+            // generic type. In that case there is no concrete expected type to
+            // trigger wrapTranslation, but Lua still needs each operand's
+            // primitive default restored before applying the operator.
+            left = normalizeBuiltinOperand(e.getLeft(), left, t);
+            right = normalizeBuiltinOperand(e.getRight(), right, t);
+        }
         if (op == WurstOperator.PLUS && overloadedOperator == null) {
             left = wrapImplicitToString(e, e.getLeft(), left, t);
             right = wrapImplicitToString(e, e.getRight(), right, t);
@@ -243,6 +251,14 @@ public static ImExpr translateIntern(ExprBinary e, ImTranslator t, ImFunction f)
         return ImOperatorCall(op, ImExprs(left, right));
     }
 
+    private static ImExpr normalizeBuiltinOperand(Expr operand, ImExpr translated, ImTranslator t) {
+        if (!t.isLuaTarget() || !(operand.attrTypRaw() instanceof WurstTypeBoundTypeParam)
+            || isAlreadyTypeAssured(translated, t)) {
+            return translated;
+        }
+        return wrapLua(operand, t, translated, operand.attrTypRaw());
+    }
+
     private static ImExpr translateConcatOperand(ExprBinary concat, Expr operand, ImTranslator t, ImFunction f,
                                                  @Nullable FuncLink overloadedOperator) {
         if (concat.getOp() == WurstOperator.PLUS && overloadedOperator == null
@@ -926,7 +942,9 @@ public static ImExpr translateIntern(ExprNewObject e, ImTranslator t, ImFunction
         WurstTypeClass wurstType = (WurstTypeClass) e.attrTyp();
         ImClass imClass = t.getClassFor(wurstType.getClassDef());
         ImTypeArguments typeArgs = getFunctionCallTypeArguments(t, sig, e, imClass.getTypeVariables());
-        return ImFunctionCall(e, constructorImFunc, typeArgs, translateExprs(e.getArgs(), t, f), false, CallType.NORMAL);
+        FunctionSignature selectedSignature = t.isLuaTarget() ? sig : null;
+        return ImFunctionCall(e, constructorImFunc, typeArgs,
+            translateExprs(e.getArgs(), t, f, false, selectedSignature), false, CallType.NORMAL);
     }
 
     public static ImExprOpt translate(NoExpr e, ImTranslator translator, ImFunction f) {

de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/LuaBackendAuditTests.java

@@ -2327,6 +2327,14 @@ public void erasedGenericPrimitiveDefaultsPropagateThroughCompositeContexts() th
             "class Addable",
             "    function op_plus(int value) returns int",
             "        return value",
+            "class Constructed",
+            "    int value",
+            "    construct(int value)",
+            "        this.value = value",
+            "    construct(string value)",
+            "        this.value = -1",
+            "    function get() returns int",
+            "        return value",
             "function consume(int value) returns int",
             "    return value",
             "function consume(string value) returns int",
@@ -2340,24 +2348,26 @@ public void erasedGenericPrimitiveDefaultsPropagateThroughCompositeContexts() th
             "    bool useBox = true",
             "    values[0] = 7",
             "    let sum = addable + box.get()",
+            "    let builtinSum = box.get() + box.get()",
             "    let overloaded = consume(useBox ? box.get() : 0)",
             "    let indexed = values[useBox ? box.get() : 0]",
             "    IntSupplier supplier = () -> (useBox ? box.get() : 0)",
             "    IntSupplier unarySupplier = () -> -box.get()",
+            "    let constructed = new Constructed(useBox ? box.get() : 0)",
             "    int blockValue = begin",
             "        return (useBox ? box.get() : 0)",
             "    end",
             "    int switchValue = -1",
             "    switch (useBox ? box.get() : 1)",
             "        case 0",
             "            switchValue = 0",
-            "    if sum == 0 and overloaded == 0 and indexed == 7 and supplier.get() == 0",
+            "    if sum == 0 and builtinSum == 0 and overloaded == 0 and indexed == 7 and supplier.get() == 0",
             "        and unarySupplier.get() == 0",
-            "        and blockValue == 0 and switchValue == 0",
+            "        and blockValue == 0 and switchValue == 0 and constructed.get() == 0",
             "        testSuccess()"
         );
         String compiled = compiledLua("erasedGenericPrimitiveDefaultsPropagateThroughCompositeContexts");
-        assertEquals("each concrete integer consumer must normalize its erased generic input", 7,
+        assertEquals("each concrete integer consumer must normalize its erased generic input", 10,
             countOccurrences(compiled, "__wurst_ensureInt(Box_Box_get("));
     }