Capture tuple operands before comparison

Author: Frotty

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

@@ -515,7 +515,7 @@ private static void removeTupleExprs(int posHint, Element elem, ImTranslator tra
                     ImExprs exprs = (ImExprs) elem;
                     if (exprs.getParent() instanceof ImOperatorCall) {
                         ImOperatorCall opCall = (ImOperatorCall) exprs.getParent();
-                        handleTupleInOpCall(replacer, opCall);
+                        handleTupleInOpCall(replacer, opCall, f);
                         return;
                     } else {
                         // in function arguments, other tuples
@@ -548,20 +548,25 @@ private static void removeTupleExprs(int posHint, Element elem, ImTranslator tra
 
     }
 
-    private static void handleTupleInOpCall(Replacer replacer, ImOperatorCall opCall) {
+    private static void handleTupleInOpCall(Replacer replacer, ImOperatorCall opCall, ImFunction f) {
         if (opCall.getParent() == null) {
             throw new RuntimeException("opCall not used: " + opCall);
         }
         ImTupleExpr left = (ImTupleExpr) opCall.getArguments().get(0);
         ImTupleExpr right = (ImTupleExpr) opCall.getArguments().get(1);
         WurstOperator op = opCall.getOp();
 
+        ImStmts evaluation = JassIm.ImStmts();
+        List<ImExpr> leftComponents = captureTupleComponents(left, evaluation, f);
+        List<ImExpr> rightComponents = captureTupleComponents(right, evaluation, f);
+        if (leftComponents.size() != rightComponents.size()) {
+            throw new CompileError(opCall.attrTrace(), "Cannot compare tuples with different arity.");
+        }
+
         List<ImExpr> componentComparisons = new ArrayList<>();
-        for (int i = 0; i < left.getExprs().size(); i++) {
-            ImExpr l = left.getExprs().get(i);
-            ImExpr r = right.getExprs().get(i);
-            l.setParent(null);
-            r.setParent(null);
+        for (int i = 0; i < leftComponents.size(); i++) {
+            ImExpr l = leftComponents.get(i);
+            ImExpr r = rightComponents.get(i);
             componentComparisons.add(JassIm.ImOperatorCall(op, JassIm.ImExprs(l, r)));
         }
 
@@ -598,7 +603,21 @@ private static void handleTupleInOpCall(Replacer replacer, ImOperatorCall opCall
             newExpr = (seen ? Optional.of(acc) : Optional.<ImExpr>empty())
                     .get();
         }
-        replacer.replace(opCall, newExpr);
+        replacer.replace(opCall, JassIm.ImStatementExpr(evaluation, newExpr));
+    }
+
+    private static List<ImExpr> captureTupleComponents(ImTupleExpr tuple, ImStmts evaluation, ImFunction f) {
+        List<ImExpr> components = new ArrayList<>();
+        List<ImExpr> flat = new ArrayList<>();
+        flattenTupleExpr(tuple, evaluation, flat);
+        for (ImExpr expr : flat) {
+            expr.setParent(null);
+            ImVar temp = JassIm.ImVar(expr.attrTrace(), expr.attrTyp(), "tuple_compare", false);
+            f.getLocals().add(temp);
+            evaluation.add(JassIm.ImSet(expr.attrTrace(), JassIm.ImVarAccess(temp), expr));
+            components.add(JassIm.ImVarAccess(temp));
+        }
+        return components;
     }
 
     private static ImStatementExpr inSet(ImSet imSet, ImTranslator translator, ImFunction f) {

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

@@ -151,6 +151,24 @@ public void tupleReturnSlotsAreSharedAcrossMultipleInterfaceRoots() throws IOExc
         assertFalse(compiled.contains("tupleEquals"));
     }
 
+    @Test
+    public void tupleReturningCallsAreCapturedBeforeComparison() throws IOException {
+        test().testLua(true).executeProg().lines(
+            "package Test",
+            "native testSuccess()",
+            "tuple pair(int x, int y)",
+            "@noinline function value(int seed) returns pair",
+            "    return pair(0, seed)",
+            "init",
+            "    if value(1) != value(2) and not (value(1) == value(2))",
+            "        testSuccess()"
+        );
+
+        String compiled = compiledLua("tupleReturningCallsAreCapturedBeforeComparison");
+        assertFalse(compiled.contains("tupleCopy"));
+        assertFalse(compiled.contains("tupleEquals"));
+    }
+
     @Test
     public void compiletimeGenericArrayReplayLeavesAreSplit() {
         String compiled = compileLuaWithRunArgs(