Revert "Emit less garbage without opts, if it has no side effects"

This reverts commit 044797f.

Author: Frotty

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/WurstCompilerJassImpl.java

@@ -561,11 +561,6 @@ public JassProg transformProgToJass() {
         // translate flattened intermediate lang to jass:
 
         beginPhase(14, "translate to jass");
-        optimizer.removeGarbage();
-        imProg.flatten(imTranslator);
-        imTranslator.removeEmptyPackageInits();
-        optimizer.removeGarbage();
-        imProg.flatten(imTranslator);
         getImTranslator().calculateCallRelationsAndUsedVariables();
         ImToJassTranslator translator =
             new ImToJassTranslator(getImProg(), getImTranslator().getCalledFunctions(), getImTranslator().getMainFunc(), getImTranslator().getConfFunc());

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/imoptimizer/ImOptimizer.java

@@ -6,7 +6,6 @@
 import de.peeeq.wurstscript.intermediatelang.optimizer.BranchMerger;
 import de.peeeq.wurstscript.intermediatelang.optimizer.ConstantAndCopyPropagation;
 import de.peeeq.wurstscript.intermediatelang.optimizer.LocalMerger;
-import de.peeeq.wurstscript.intermediatelang.optimizer.SideEffectAnalyzer;
 import de.peeeq.wurstscript.intermediatelang.optimizer.SimpleRewrites;
 import de.peeeq.wurstscript.jassIm.*;
 import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
@@ -98,9 +97,6 @@ public void removeGarbage() {
         while (changes && iterations++ < 10) {
             ImProg prog = trans.imProg();
             trans.calculateCallRelationsAndUsedVariables();
-            SideEffectAnalyzer sideEffectAnalyzer = new SideEffectAnalyzer(prog);
-            Map<ImFunction, Boolean> sideEffectCache = new HashMap<>();
-            Set<ImFunction> sideEffectInProgress = new HashSet<>();
 
             // keep only used variables
             int globalsBefore = prog.getGlobals().size();
@@ -141,30 +137,25 @@ public void visit(ImSet e) {
                         if (e.getLeft() instanceof ImVarAccess) {
                             ImVarAccess va = (ImVarAccess) e.getLeft();
                             if (!trans.getReadVariables().contains(va.getVar()) && !TRVEHelper.protectedVariables.contains(va.getVar().getName())) {
-                                List<ImExpr> sideEffects = collectSideEffects(e.getRight(), sideEffectAnalyzer, sideEffectCache, sideEffectInProgress);
-                                replacements.add(Pair.create(e, sideEffects));
+                                replacements.add(Pair.create(e, Collections.singletonList(e.getRight())));
                             }
                         } else if (e.getLeft() instanceof ImVarArrayAccess) {
                             ImVarArrayAccess va = (ImVarArrayAccess) e.getLeft();
                             if (!trans.getReadVariables().contains(va.getVar()) && !TRVEHelper.protectedVariables.contains(va.getVar().getName())) {
-                                List<ImExpr> exprs = new ArrayList<>();
-                                for (ImExpr index : va.getIndexes()) {
-                                    exprs.addAll(collectSideEffects(index, sideEffectAnalyzer, sideEffectCache, sideEffectInProgress));
-                                }
-                                exprs.addAll(collectSideEffects(e.getRight(), sideEffectAnalyzer, sideEffectCache, sideEffectInProgress));
+                                // IMPORTANT: removeAll() clears parent references
+                                List<ImExpr> exprs = va.getIndexes().removeAll();
+                                exprs.add(e.getRight());
                                 replacements.add(Pair.create(e, exprs));
                             }
                         } else if (e.getLeft() instanceof ImTupleSelection) {
                             ImVar var = TypesHelper.getTupleVar((ImTupleSelection) e.getLeft());
                             if(var != null && !trans.getReadVariables().contains(var) && !TRVEHelper.protectedVariables.contains(var.getName())) {
-                                List<ImExpr> sideEffects = collectSideEffects(e.getRight(), sideEffectAnalyzer, sideEffectCache, sideEffectInProgress);
-                                replacements.add(Pair.create(e, sideEffects));
+                                replacements.add(Pair.create(e, Collections.singletonList(e.getRight())));
                             }
                         } else if(e.getLeft() instanceof ImMemberAccess) {
                             ImMemberAccess va = ((ImMemberAccess) e.getLeft());
                             if (!trans.getReadVariables().contains(va.getVar()) && !TRVEHelper.protectedVariables.contains(va.getVar().getName())) {
-                                List<ImExpr> sideEffects = collectSideEffects(e.getRight(), sideEffectAnalyzer, sideEffectCache, sideEffectInProgress);
-                                replacements.add(Pair.create(e, sideEffects));
+                                replacements.add(Pair.create(e, Collections.singletonList(e.getRight())));
                             }
                         }
                     }
@@ -174,9 +165,7 @@ public void visit(ImSet e) {
                 for (Pair<ImStmt, List<ImExpr>> pair : replacements) {
                     changes = true;
                     ImExpr r;
-                    if (pair.getB().isEmpty()) {
-                        r = ImHelper.statementExprVoid(JassIm.ImStmts());
-                    } else if (pair.getB().size() == 1) {
+                    if (pair.getB().size() == 1) {
                         r = pair.getB().get(0);
                         // CRITICAL: Clear parent before reusing the node
                         r.setParent(null);
@@ -198,83 +187,4 @@ public void visit(ImSet e) {
             }
         }
     }
-
-    private List<ImExpr> collectSideEffects(ImExpr expr, SideEffectAnalyzer analyzer, Map<ImFunction, Boolean> cache,
-                                            Set<ImFunction> inProgress) {
-        if (expr == null) {
-            return Collections.emptyList();
-        }
-        if (hasSideEffects(expr, analyzer, cache, inProgress)) {
-            return Collections.singletonList(expr);
-        }
-        return Collections.emptyList();
-    }
-
-    private boolean hasSideEffects(ImExpr expr, SideEffectAnalyzer analyzer, Map<ImFunction, Boolean> cache,
-                                   Set<ImFunction> inProgress) {
-        if (expr instanceof ImDealloc || expr instanceof ImGetStackTrace || expr instanceof ImTypeVarDispatch) {
-            return true;
-        }
-        if (!SideEffectAnalyzer.quickcheckHasSideeffects(expr)) {
-            return false;
-        }
-        for (ImVar var : analyzer.directlySetVariables(expr)) {
-            if (var.isGlobal()) {
-                return true;
-            }
-        }
-        for (ImFunction nativeFunc : analyzer.calledNatives(expr)) {
-            if (!UselessFunctionCallsRemover.isFunctionWithoutSideEffect(nativeFunc.getName())) {
-                return true;
-            }
-        }
-        for (ImFunction called : analyzer.calledFunctions(expr)) {
-            if (functionHasSideEffects(called, analyzer, cache, inProgress)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean functionHasSideEffects(ImFunction func, SideEffectAnalyzer analyzer, Map<ImFunction, Boolean> cache,
-                                           Set<ImFunction> inProgress) {
-        Boolean cached = cache.get(func);
-        if (cached != null) {
-            return cached;
-        }
-        if (func.isNative()) {
-            boolean sideEffect = !UselessFunctionCallsRemover.isFunctionWithoutSideEffect(func.getName());
-            cache.put(func, sideEffect);
-            return sideEffect;
-        }
-        if (!inProgress.add(func)) {
-            return true;
-        }
-        boolean sideEffect = false;
-        for (ImVar var : analyzer.directlySetVariables(func.getBody())) {
-            if (var.isGlobal()) {
-                sideEffect = true;
-                break;
-            }
-        }
-        if (!sideEffect) {
-            for (ImFunction nativeFunc : analyzer.calledNatives(func.getBody())) {
-                if (!UselessFunctionCallsRemover.isFunctionWithoutSideEffect(nativeFunc.getName())) {
-                    sideEffect = true;
-                    break;
-                }
-            }
-        }
-        if (!sideEffect) {
-            for (ImFunction called : analyzer.calledFunctions(func.getBody())) {
-                if (functionHasSideEffects(called, analyzer, cache, inProgress)) {
-                    sideEffect = true;
-                    break;
-                }
-            }
-        }
-        inProgress.remove(func);
-        cache.put(func, sideEffect);
-        return sideEffect;
-    }
 }

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

@@ -455,29 +455,6 @@ private static ImStatementExpr inSet(ImSet imSet, ImFunction f) {
                 + "\nLHS=" + left + "\nRHS=" + right);
         }
 
-        boolean allLiteral = true;
-        for (ImExpr r : rhsLeaves) {
-            if (!isSimpleLiteral(r)) {
-                allLiteral = false;
-                break;
-            }
-        }
-
-        if (allLiteral) {
-            for (int i = 0; i < lhsLeaves.size(); i++) {
-                ImLExpr l = lhsLeaves.get(i);
-                ImType targetT = l.attrTyp();
-                ImExpr r = rhsLeaves.get(i);
-                if (r instanceof ImNull) {
-                    r = ImHelper.defaultValueForComplexType(targetT);
-                }
-                l.setParent(null);
-                r.setParent(null);
-                stmts.add(JassIm.ImSet(imSet.getTrace(), l, r));
-            }
-            return ImHelper.statementExprVoid(stmts);
-        }
-
         // 4) Evaluate RHS leaves first into temps (preserve side-effect order & alias safety)
         List<ImVar> temps = new ArrayList<>(rhsLeaves.size());
         for (int i = 0; i < rhsLeaves.size(); i++) {
@@ -508,14 +485,6 @@ private static ImStatementExpr inSet(ImSet imSet, ImFunction f) {
         return ImHelper.statementExprVoid(stmts);
     }
 
-    private static boolean isSimpleLiteral(ImExpr expr) {
-        return expr instanceof ImBoolVal
-            || expr instanceof ImIntVal
-            || expr instanceof ImRealVal
-            || expr instanceof ImStringVal
-            || expr instanceof ImNull;
-    }
-
     /** Flatten LHS recursively into addressable leaves (ImLExpr), hoisting side-effects */
     private static void flattenLhsTuple(ImExpr e, List<ImLExpr> out, ImStmts sideStmts) {
         ImExpr x = extractSideEffect(e, sideStmts);

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

@@ -183,154 +183,6 @@ public ImProg translateProg() {
         }
     }
 
-    public void removeEmptyPackageInits() {
-        Set<ImFunction> emptyInitFunctions = new HashSet<>();
-        for (ImFunction initFunc : imProg.getFunctions()) {
-            if (initFunc.getName().startsWith("init_") && isTrivialInitFunction(initFunc)) {
-                emptyInitFunctions.add(initFunc);
-            }
-        }
-        if (emptyInitFunctions.isEmpty()) {
-            return;
-        }
-
-        Map<ImVar, ImFunction> initFuncRefs = collectInitFuncRefs();
-        removeInitCallsFromMain(emptyInitFunctions, initFuncRefs);
-        removeInitFuncRefsFromGlobals(emptyInitFunctions);
-        imProg.getFunctions().removeIf(emptyInitFunctions::contains);
-        initFuncMap.values().removeIf(emptyInitFunctions::contains);
-    }
-
-    private boolean isTrivialInitFunction(ImFunction initFunc) {
-        if (initFunc.getBody().isEmpty()) {
-            return true;
-        }
-        if (initFunc.getBody().size() != 1) {
-            return false;
-        }
-        ImStmt stmt = initFunc.getBody().get(0);
-        if (!(stmt instanceof ImReturn)) {
-            return false;
-        }
-        ImExprOpt returnValue = ((ImReturn) stmt).getReturnValue();
-        if (returnValue instanceof ImNoExpr) {
-            return true;
-        }
-        return returnValue instanceof ImBoolVal && ((ImBoolVal) returnValue).getValB();
-    }
-
-    private void removeInitCallsFromMain(Set<ImFunction> emptyInitFunctions, Map<ImVar, ImFunction> initFuncRefs) {
-        ImFunction main = getMainFunc();
-        if (main == null) {
-            return;
-        }
-
-        ImFunction native_TriggerAddCondition = getNativeFunc("TriggerAddCondition");
-        ImFunction native_Condition = getNativeFunc("Condition");
-        ImFunction native_ClearTrigger = getNativeFunc("TriggerClearConditions");
-
-        ImStmts mainBody = main.getBody();
-        for (int i = 0; i < mainBody.size(); i++) {
-            ImStmt stmt = mainBody.get(i);
-            if (stmt instanceof ImFunctionCall) {
-                ImFunctionCall call = (ImFunctionCall) stmt;
-                if (emptyInitFunctions.contains(call.getFunc())) {
-                    mainBody.remove(i--);
-                    continue;
-                }
-                if (native_TriggerAddCondition != null && native_Condition != null
-                        && call.getFunc() == native_TriggerAddCondition
-                        && hasInitCondition(call, native_Condition, emptyInitFunctions, initFuncRefs)) {
-                    if (i + 2 < mainBody.size()
-                            && mainBody.get(i + 1) instanceof ImIf
-                            && isTriggerClear(mainBody.get(i + 2), native_ClearTrigger)) {
-                        mainBody.remove(i + 2);
-                        mainBody.remove(i + 1);
-                        mainBody.remove(i--);
-                    }
-                }
-            }
-        }
-    }
-
-    private void removeInitFuncRefsFromGlobals(Set<ImFunction> emptyInitFunctions) {
-        ImFunction globalInit = getGlobalInitFunc();
-        if (globalInit == null) {
-            return;
-        }
-        ImStmts body = globalInit.getBody();
-        for (int i = 0; i < body.size(); i++) {
-            ImStmt stmt = body.get(i);
-            if (!(stmt instanceof ImSet)) {
-                continue;
-            }
-            ImExpr right = ((ImSet) stmt).getRight();
-            if (right instanceof ImFuncRef && emptyInitFunctions.contains(((ImFuncRef) right).getFunc())) {
-                body.remove(i--);
-            }
-        }
-    }
-
-    private Map<ImVar, ImFunction> collectInitFuncRefs() {
-        ImFunction globalInit = getGlobalInitFunc();
-        if (globalInit == null) {
-            return Collections.emptyMap();
-        }
-        Map<ImVar, ImFunction> refs = new HashMap<>();
-        ImStmts body = globalInit.getBody();
-        for (int i = 0; i < body.size(); i++) {
-            ImStmt stmt = body.get(i);
-            if (!(stmt instanceof ImSet)) {
-                continue;
-            }
-            ImSet set = (ImSet) stmt;
-            if (!(set.getLeft() instanceof ImVarAccess)) {
-                continue;
-            }
-            if (!(set.getRight() instanceof ImFuncRef)) {
-                continue;
-            }
-            refs.put(((ImVarAccess) set.getLeft()).getVar(), ((ImFuncRef) set.getRight()).getFunc());
-        }
-        return refs;
-    }
-
-    private boolean hasInitCondition(ImFunctionCall call, ImFunction nativeCondition, Set<ImFunction> emptyInitFunctions,
-                                     Map<ImVar, ImFunction> initFuncRefs) {
-        if (call.getArguments().size() < 2) {
-            return false;
-        }
-        ImExpr conditionExpr = call.getArguments().get(1);
-        if (!(conditionExpr instanceof ImFunctionCall)) {
-            return false;
-        }
-        ImFunctionCall conditionCall = (ImFunctionCall) conditionExpr;
-        if (conditionCall.getFunc() != nativeCondition) {
-            return false;
-        }
-        if (conditionCall.getArguments().size() != 1) {
-            return false;
-        }
-        ImExpr argument = conditionCall.getArguments().get(0);
-        if (argument instanceof ImFuncRef) {
-            ImFuncRef funcRef = (ImFuncRef) argument;
-            return emptyInitFunctions.contains(funcRef.getFunc());
-        }
-        if (argument instanceof ImVarAccess) {
-            ImVar var = ((ImVarAccess) argument).getVar();
-            ImFunction target = initFuncRefs.get(var);
-            return target != null && emptyInitFunctions.contains(target);
-        }
-        return false;
-    }
-
-    private boolean isTriggerClear(ImStmt stmt, ImFunction nativeClearTrigger) {
-        if (nativeClearTrigger == null) {
-            return false;
-        }
-        return stmt instanceof ImFunctionCall && ((ImFunctionCall) stmt).getFunc() == nativeClearTrigger;
-    }
-
     /**
      * Number all the compiletime functions and expressions,
      * so that the one with the lowest number can be executed first.