wurstscript / WurstScript / 220

Committed 22 Nov 2023 12:57PM UTC coverage: 62.564% (-0.04%) from 62.602%

Build # 220

Build Type

Pull #1081

circleci

Committed by

Frotty

Commit Message

Update MapRequest.java

Pull Request Pull Request #1081: More performance improvements

Run Details

17307 of 27663 relevant lines covered (62.56%)

0.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.7

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

package de.peeeq.wurstscript.translation.imtranslation;

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import de.peeeq.wurstscript.WurstOperator;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.jassIm.ImCompiletimeExpr;
import de.peeeq.wurstscript.jassIm.ImExitwhen;
import de.peeeq.wurstscript.jassIm.ImFunction;
import de.peeeq.wurstscript.jassIm.ImFunctionCall;
import de.peeeq.wurstscript.jassIm.ImGetStackTrace;
import de.peeeq.wurstscript.jassIm.ImIf;
import de.peeeq.wurstscript.jassIm.ImLoop;
import de.peeeq.wurstscript.jassIm.ImMemberAccess;
import de.peeeq.wurstscript.jassIm.ImOperatorCall;
import de.peeeq.wurstscript.jassIm.ImProg;
import de.peeeq.wurstscript.jassIm.ImReturn;
import de.peeeq.wurstscript.jassIm.ImSet;
import de.peeeq.wurstscript.jassIm.ImStatementExpr;
import de.peeeq.wurstscript.jassIm.ImStmts;
import de.peeeq.wurstscript.jassIm.ImTupleExpr;
import de.peeeq.wurstscript.jassIm.ImTupleSelection;
import de.peeeq.wurstscript.jassIm.ImVar;
import de.peeeq.wurstscript.jassIm.ImVarAccess;
import de.peeeq.wurstscript.jassIm.ImVarArrayAccess;
import de.peeeq.wurstscript.jassIm.ImVarargLoop;
import de.peeeq.wurstscript.translation.imtranslation.purity.Pure;
import de.peeeq.wurstscript.types.WurstTypeBool;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static de.peeeq.wurstscript.jassIm.JassIm.*;

/**
 * flattening expressions and statements
 * after flattening there will be no more StatementExprs
 * for expressions there might be a StatementExpr on the top level
 * <p>
 * TODO wait, its not that easy: you have to make sure that the execution order is not changed for functions and global variables
 * <p>
 * e.g. take
 * <p>
 * y = x + StatementExpr(setX(4), 2)
 * <p>
 * this should be translated to:
 * <p>
 * temp = x
 * setX(4)
 * y = temp + 2
 * <p>
 * <p>
 * alternative: relax language semantics
 */
public class Flatten {


    public static Result flatten(ImTypeVarDispatch imTypeVarDispatch, ImTranslator translator, ImFunction f) {
        throw new RuntimeException("called too early");
    }

    public static Result flatten(ImCast imCast, ImTranslator translator, ImFunction f) {
        Result res = imCast.getExpr().flatten(translator, f);
        return new Result(res.stmts, ImCast(res.expr, imCast.getToType()));
    }

    public static Result flatten(ImTypeIdOfObj e, ImTranslator translator, ImFunction f) {
        Result o = e.getObj().flatten(translator, f);
        return new Result(o.stmts, ImTypeIdOfObj(o.expr, e.getClazz()));
    }

    public static Result flatten(ImTypeIdOfClass e, ImTranslator translator, ImFunction f) {
        e.setParent(null);
        return new Result(e);
    }

    public static Result flatten(ImDealloc d, ImTranslator translator, ImFunction f) {
        Result o = d.getObj().flatten(translator, f);
        return new Result(o.stmts, ImDealloc(d.getTrace(), d.getClazz(), o.expr));
    }

    public static Result flatten(ImInstanceof e, ImTranslator translator, ImFunction f) {
        Result res = e.getObj().flatten(translator, f);
        return new Result(res.stmts, ImInstanceof(res.expr, e.getClazz()));
    }

    public static Result flatten(ImAlloc e, ImTranslator translator, ImFunction f) {
        e.setParent(null);
        return new Result(e);
    }


    public static class Result {

        List<ImStmt> stmts;
        final ImExpr expr;

        public Result(List<ImStmt> stmts, ImExpr expr) {
            Preconditions.checkArgument(expr.getParent() == null, "expression must not have a parent");
            Preconditions.checkArgument(stmts.stream().allMatch(s -> s.getParent() == null), "statement must not have a parent");
            this.stmts = stmts;
            this.expr = expr;
        }

        public Result(ImExpr expr) {
            this(Collections.emptyList(), expr);
        }

        public Result(List<ImStmt> stmts) {
            this(stmts, ImHelper.nullExpr());
        }

        public void intoStatements(List<ImStmt> result, ImTranslator t, ImFunction f) {
            result.addAll(stmts);
            exprToStatements(result, expr, t, f);
        }

        public List<ImStmt> getStmts() {
            return stmts;
        }

        public ImExpr getExpr() {
            return expr;
        }

        public ImStatementExpr toStatementExpr() {
            return JassIm.ImStatementExpr(JassIm.ImStmts(stmts), expr);
        }

        public void addStmts(List<ImStmt> stmts) {
            if (stmts.isEmpty()) {
                return;
            }
            this.stmts = new ArrayList<>(this.stmts);
            this.stmts.addAll(stmts);
        }
    }

    public static class ResultL extends Result {
        public ResultL(List<ImStmt> stmts, ImLExpr expr) {
            super(stmts, expr);
        }

        public ResultL(ImLExpr expr) {
            super(expr);
        }

        @Override
        public ImLExpr getExpr() {
            return (ImLExpr) super.getExpr();
        }
    }

    public static class MultiResult {

        final List<ImStmt> stmts;
        final List<ImExpr> exprs;

        public MultiResult(List<ImStmt> stmts, List<ImExpr> exprs) {
            this.stmts = stmts;
            this.exprs = exprs;
        }


        public ImExpr expr(int i) {
            return exprs.get(i);
        }

    }

    public static class MultiResultL extends MultiResult {

        public MultiResultL(List<ImStmt> stmts, List<ImLExpr> exprs) {
            super(stmts, ImmutableList.copyOf(exprs));
        }

        public ImLExpr expr(int i) {
            return (ImLExpr) super.expr(i);
        }

        public List<ImLExpr> getLExprs() {
            //noinspection unchecked,rawtypes
            return (List) exprs;
        }

    }

    private static void exprToStatements(List<ImStmt> result, Element e, ImTranslator t, ImFunction f) {
        if (e instanceof ImFunctionCall) {
            Result res = flatten((ImFunctionCall) e, t, f);
            result.addAll(res.stmts);
            result.add(res.expr);
        } else if (e instanceof ImDealloc) {
            Result res = flatten((ImDealloc) e, t, f);
            result.addAll(res.stmts);
            result.add(res.expr);
        } else if (e instanceof ImMethodCall) {
            Result res = flatten((ImMethodCall) e, t, f);
            result.addAll(res.stmts);
            result.add(res.expr);
        } else if (e instanceof ImStatementExpr) {
            ImStatementExpr e2 = (ImStatementExpr) e;
            flattenStatementsInto(result, e2.getStatements(), t, f);
            exprToStatements(result, e2, t, f);
        } else if (e instanceof ImOperatorCall &&
            (((ImOperatorCall) e).getOp() == WurstOperator.AND
                || ((ImOperatorCall) e).getOp() == WurstOperator.OR)) {
            // short circuiting operators have to be handled in a special way:
            // we translate them to if statements when necessary
            ImOperatorCall oc = (ImOperatorCall) e;
            ImStmts rightStmts = JassIm.ImStmts();
            ImExpr right = oc.getArguments().get(1);
            ImExpr left = oc.getArguments().get(0);
            exprToStatements(rightStmts, right, t, f);
            if (rightStmts.isEmpty()) {
                // if no statements for righthand side, then just use left hand side as result
                exprToStatements(result, left, t, f);
            } else {
                // if righthandside contains some statements, transform the whole thing to an if statement:
                if (oc.getOp() == WurstOperator.AND) {
                    result.add(JassIm.ImIf(e.attrTrace(), left.copy(), rightStmts, JassIm.ImStmts()));
                } else { // WurstOperator.OR
                    result.add(JassIm.ImIf(e.attrTrace(), left.copy(), JassIm.ImStmts(), rightStmts));
                }
            }
        } else {
            // visit children:
            for (int i = 0; i < e.size(); i++) {
                exprToStatements(result, e.get(i), t, f);
            }
        }
    }


    private static ImStmts flattenStatements(ImStmts statements, ImTranslator t, ImFunction f) {
        ImStmts result = ImStmts();
        flattenStatementsInto(result, statements, t, f);
        return result;
    }

    private static void flattenStatementsInto(List<ImStmt> result, ImStmts statements, ImTranslator t, ImFunction f) {
        for (ImStmt s : statements) {
            s.flatten(t, f).intoStatements(result, t, f);
        }
    }

    public static Result flatten(ImExitwhen s, ImTranslator t, ImFunction f) {
        Result cond = s.getCondition().flatten(t, f);
        List<ImStmt> stmts = Lists.newArrayList(cond.stmts);
        stmts.add(ImExitwhen(s.getTrace(), cond.expr));
        return new Result(stmts);
    }


    public static Result flatten(ImIf s, ImTranslator t, ImFunction f) {
        Result cond = s.getCondition().flatten(t, f);
        List<ImStmt> stmts = Lists.newArrayList(cond.stmts);
        stmts.add(
            JassIm.ImIf(s.getTrace(), cond.expr,
                flattenStatements(s.getThenBlock(), t, f),
                flattenStatements(s.getElseBlock(), t, f)));
        return new Result(stmts);
    }


    public static Result flatten(ImLoop s, ImTranslator t, ImFunction f) {
        return new Result(Collections.singletonList(
            JassIm.ImLoop(s.getTrace(), flattenStatements(s.getBody(), t, f))));
    }

    public static Result flatten(ImReturn s, ImTranslator t, ImFunction f) {
        if (s.getReturnValue() instanceof ImExpr) {
            ImExpr ret = (ImExpr) s.getReturnValue();
            Result result = ret.flatten(t, f);
            List<ImStmt> stmts = Lists.newArrayList(result.stmts);
            stmts.add(ImReturn(s.getTrace(), result.expr));
            return new Result(stmts);
        } else {
            s.setParent(null);
            return new Result(Collections.singletonList(s));
        }
    }


    public static Result flatten(ImSet s, ImTranslator t, ImFunction f) {
        Result l = s.getLeft().flatten(t, f);
        Result r = s.getRight().flatten(t, f);
        List<ImStmt> stmts = Lists.newArrayList(l.stmts);
        stmts.addAll(r.stmts);
        stmts.add(JassIm.ImSet(s.getTrace(), (ImLExpr) l.expr, r.expr));
        return new Result(stmts);
    }


    public static Result flatten(ImFunctionCall e, ImTranslator t, ImFunction f) {
        MultiResult r = flattenExprs(t, f, e.getArguments());
        return new Result(r.stmts, ImFunctionCall(e.getTrace(), e.getFunc(), e.getTypeArguments().copy(), ImExprs(r.exprs), e.getTuplesEliminated(), e.getCallType()));
    }

    public static Result flatten(ImMethodCall e, ImTranslator t, ImFunction f) {
        Result recR = e.getReceiver().flatten(t, f);
        MultiResult argsR = flattenExprs(t, f, e.getArguments());
        Result res = new Result(recR.stmts, ImMethodCall(e.getTrace(), e.getMethod(), e.getTypeArguments().copy(), recR.expr, ImExprs(argsR.exprs), e.getTuplesEliminated()));
        res.addStmts(argsR.stmts);
        return res;
    }

    public static Result flatten(ImOperatorCall e, ImTranslator t, ImFunction f) {
        // TODO special case and, or
        de.peeeq.wurstscript.ast.Element trace = e.attrTrace();
        switch (e.getOp()) {
            case AND: {
                Result left = e.getArguments().get(0).flatten(t, f);
                Result right = e.getArguments().get(1).flatten(t, f);

                if (right.stmts.isEmpty()) {
                    return new Result(left.stmts, JassIm.ImOperatorCall(WurstOperator.AND, ImExprs(left.expr, right.expr)));
                } else {
                    ArrayList<ImStmt> stmts = Lists.newArrayList(left.stmts);
                    ImVar tempVar = JassIm.ImVar(e.attrTrace(), WurstTypeBool.instance().imTranslateType(t), "andLeft", false);
                    f.getLocals().add(tempVar);
                    ImStmts thenBlock = JassIm.ImStmts();
                    // if left is true then check right
                    thenBlock.addAll(right.stmts);
                    thenBlock.add(ImSet(trace, ImVarAccess(tempVar), right.expr));
                    // else the result is false
                    ImStmts elseBlock = JassIm.ImStmts(ImSet(trace, ImVarAccess(tempVar), JassIm.ImBoolVal(false)));
                    stmts.add(ImIf(trace, left.expr, thenBlock, elseBlock));
                    return new Result(stmts, JassIm.ImVarAccess(tempVar));
                }
            }
            case OR: {
                Result left = e.getArguments().get(0).flatten(t, f);
                Result right = e.getArguments().get(1).flatten(t, f);

                if (right.stmts.isEmpty()) {
                    return new Result(left.stmts, JassIm.ImOperatorCall(WurstOperator.OR, ImExprs(left.expr, right.expr)));
                } else {
                    ArrayList<ImStmt> stmts = Lists.newArrayList(left.stmts);
                    ImVar tempVar = JassIm.ImVar(trace, WurstTypeBool.instance().imTranslateType(t), "andLeft", false);
                    f.getLocals().add(tempVar);
                    // if left is true then result is ture
                    ImStmts thenBlock = JassIm.ImStmts(ImSet(trace, ImVarAccess(tempVar), JassIm.ImBoolVal(true)));
                    // else check right
                    ImStmts elseBlock = JassIm.ImStmts();
                    elseBlock.addAll(right.stmts);
                    elseBlock.add(ImSet(trace, ImVarAccess(tempVar), right.expr));
                    stmts.add(ImIf(trace, left.expr, thenBlock, elseBlock));
                    return new Result(stmts, JassIm.ImVarAccess(tempVar));
                }
            }
            default:
                MultiResult r = flattenExprs(t, f, e.getArguments());
                return new Result(r.stmts, JassIm.ImOperatorCall(e.getOp(), ImExprs(r.exprs)));
        }
    }


    public static Result flatten(ImConst e, ImTranslator t, ImFunction f) {
        e.setParent(null);
        return new Result(e);
    }


    public static Result flatten(ImStatementExpr e, ImTranslator t, ImFunction f) {
        List<ImStmt> stmts = Lists.newArrayList();
        flattenStatementsInto(stmts, e.getStatements(), t, f);
        Result r = e.getExpr().flatten(t, f);
        stmts.addAll(r.stmts);
        return new Result(stmts, r.expr);
    }

    public static ResultL flattenL(ImStatementExpr e, ImTranslator t, ImFunction f) {
        List<ImStmt> stmts = Lists.newArrayList();
        flattenStatementsInto(stmts, e.getStatements(), t, f);
        ResultL r = ((ImLExpr) e.getExpr()).flattenL(t, f);
        stmts.addAll(r.stmts);
        return new ResultL(stmts, r.getExpr());
    }


    public static Result flatten(ImTupleExpr e, ImTranslator t, ImFunction f) {
        MultiResult r = flattenExprs(t, f, e.getExprs());
        return new Result(r.stmts, JassIm.ImTupleExpr(ImExprs(r.exprs)));
    }

    public static ResultL flattenL(ImTupleExpr e, ImTranslator t, ImFunction f) {
        @SuppressWarnings({"unchecked", "rawtypes"})
        List<ImLExpr> exprs = (List) e.getExprs();
        MultiResultL r = flattenExprsL(t, f, exprs);
        ImExprs newExprs = ImExprs();
        newExprs.addAll(r.getLExprs());
        return new ResultL(r.stmts, JassIm.ImTupleExpr(newExprs));
    }


    public static Result flatten(ImTupleSelection e, ImTranslator t, ImFunction f) {
        return flattenL(e, t, f);
    }

    public static ResultL flattenL(ImTupleSelection e, ImTranslator t, ImFunction f) {
        Result r = e.getTupleExpr().flatten(t, f);
        ImLExpr tupleExpr;
        List<ImStmt> stmts;
        if (r.expr instanceof ImLExpr) {
            tupleExpr = (ImLExpr) r.expr;
            stmts = r.stmts;
        } else {
            // in the unlikely event that this is not an l-value (e.g. foo().x)
            // we create a temporary variable and store the result there
            ImVar v = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "tuple_temp", false);
            f.getLocals().add(v);
            stmts = new ArrayList<>(r.stmts);
            stmts.add(JassIm.ImSet(e.attrTrace(), ImVarAccess(v), r.expr));
            tupleExpr = JassIm.ImVarAccess(v);
        }
        return new ResultL(stmts, JassIm.ImTupleSelection(tupleExpr, e.getTupleIndex()));
    }

    public static ResultL flattenL(ImVarAccess e, ImTranslator t, ImFunction f) {
        e.setParent(null);
        return new ResultL(e);
    }


    public static ResultL flatten(ImLExpr e, ImTranslator t, ImFunction f) {
        return e.flattenL(t, f);
    }

    public static ResultL flattenL(ImVarArrayAccess e, ImTranslator t, ImFunction f) {
        MultiResult indexes = flattenExprs(t, f, e.getIndexes());
        return new ResultL(indexes.stmts, ImVarArrayAccess(e.getTrace(), e.getVar(), ImExprs(indexes.exprs)));
    }


    public static void flattenFunc(ImFunction f, ImTranslator translator) {
        ImStmts newBody = flattenStatements(f.getBody(), translator, f);
        f.setBody(newBody);
    }

    public static void flattenProg(ImProg imProg, ImTranslator translator) {
        imProg.getFunctions().parallelStream().forEach(f -> f.flatten(translator));
        imProg.getClasses().parallelStream().forEach(c ->
            c.getFunctions().parallelStream().forEach(f -> f.flatten(translator)));

        translator.assertProperties(AssertProperty.FLAT);
    }

    public static Result flatten(ImCompiletimeExpr e, ImTranslator translator, ImFunction f) {
        e.setParent(null);
        return new Result(e);
    }


    private static MultiResult flattenExprs(ImTranslator t, ImFunction f, ImExpr... exprs) {
        return flattenExprs(t, f, Arrays.asList(exprs));
    }

    private static MultiResult flattenExprs(ImTranslator t, ImFunction f, List<ImExpr> exprs) {
        // TODO optimize this function to use less temporary variables
        List<ImStmt> stmts = Lists.newArrayList();
        List<ImExpr> newExprs = Lists.newArrayList();
        List<Result> results = Lists.newArrayList();
        int withStmts = -1;
        for (int i = 0; i < exprs.size(); i++) {
            Result r = exprs.get(i).flatten(t, f);
            results.add(r);
            if (!r.stmts.isEmpty()) {
                withStmts = i;
            }
        }
        for (int i = 0; i < exprs.size(); i++) {
            ImExpr e = exprs.get(i);
            Result r = results.get(i);

            stmts.addAll(r.stmts);
            if (r.expr.attrPurity() instanceof Pure
                || i >= withStmts) {
                newExprs.add(r.expr);
            } else {
                ImVar tempVar = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "temp", false);
                f.getLocals().add(tempVar);
                stmts.add(ImSet(e.attrTrace(), ImVarAccess(tempVar), r.expr));
                newExprs.add(JassIm.ImVarAccess(tempVar));
            }
        }
        return new MultiResult(stmts, newExprs);
    }

    private static MultiResultL flattenExprsL(ImTranslator t, ImFunction f, List<ImLExpr> exprs) {
        // TODO optimize this function to use less temporary variables
        List<ImStmt> stmts = Lists.newArrayList();
        List<ImLExpr> newExprs = Lists.newArrayList();
        List<ResultL> results = Lists.newArrayList();
        int withStmts = -1;
        for (int i = 0; i < exprs.size(); i++) {
            ResultL r = exprs.get(i).flattenL(t, f);
            results.add(r);
            if (!r.stmts.isEmpty()) {
                withStmts = i;
            }
        }
        for (int i = 0; i < exprs.size(); i++) {
            ImExpr e = exprs.get(i);
            ResultL r = results.get(i);

            stmts.addAll(r.stmts);
            if (r.expr.attrPurity() instanceof Pure
                || i >= withStmts) {
                newExprs.add(r.getExpr());
            } else {
                ImVar tempVar = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "temp", false);
                f.getLocals().add(tempVar);
                stmts.add(ImSet(e.attrTrace(), ImVarAccess(tempVar), r.expr));
                newExprs.add(JassIm.ImVarAccess(tempVar));
            }
        }
        return new MultiResultL(stmts, newExprs);
    }


    public static Result flatten(ImMemberAccess e,
                                 ImTranslator t, ImFunction f) {
        Result rr = e.getReceiver().flatten(t, f);
        MultiResult ir = flattenExprs(t, f, e.getIndexes());
        Result res = new Result(rr.stmts, ImMemberAccess(e.getTrace(), rr.expr, e.getTypeArguments().copy(), e.getVar(), ImExprs(ir.exprs)));
        res.addStmts(ir.stmts);
        return res;
    }

    public static ResultL flattenL(ImMemberAccess e,
                                   ImTranslator t, ImFunction f) {
        Result rr = e.getReceiver().flatten(t, f);
        MultiResult ir = flattenExprs(t, f, e.getIndexes());
        ResultL res = new ResultL(rr.stmts, ImMemberAccess(e.getTrace(), rr.expr, e.getTypeArguments(), e.getVar(), ImExprs(ir.exprs)));
        res.addStmts(ir.stmts);
        return res;
    }


    public static Result flatten(ImGetStackTrace e, ImTranslator translator,
                                 ImFunction f) {
        e.setParent(null);
        return new Result(e);
    }


    public static Result flatten(ImVarargLoop s, ImTranslator translator, ImFunction f) {
        return new Result(Collections.singletonList(
            JassIm.ImVarargLoop(s.getTrace(), flattenStatements(s.getBody(), translator, f), s.getLoopVar())));
    }


}

1	package de.peeeq.wurstscript.translation.imtranslation;
2
3	import com.google.common.base.Preconditions;
4	import com.google.common.collect.ImmutableList;
5	import com.google.common.collect.Lists;
6	import de.peeeq.wurstscript.WurstOperator;
7	import de.peeeq.wurstscript.jassIm.*;
8	import de.peeeq.wurstscript.jassIm.ImCompiletimeExpr;
9	import de.peeeq.wurstscript.jassIm.ImExitwhen;
10	import de.peeeq.wurstscript.jassIm.ImFunction;
11	import de.peeeq.wurstscript.jassIm.ImFunctionCall;
12	import de.peeeq.wurstscript.jassIm.ImGetStackTrace;
13	import de.peeeq.wurstscript.jassIm.ImIf;
14	import de.peeeq.wurstscript.jassIm.ImLoop;
15	import de.peeeq.wurstscript.jassIm.ImMemberAccess;
16	import de.peeeq.wurstscript.jassIm.ImOperatorCall;
17	import de.peeeq.wurstscript.jassIm.ImProg;
18	import de.peeeq.wurstscript.jassIm.ImReturn;
19	import de.peeeq.wurstscript.jassIm.ImSet;
20	import de.peeeq.wurstscript.jassIm.ImStatementExpr;
21	import de.peeeq.wurstscript.jassIm.ImStmts;
22	import de.peeeq.wurstscript.jassIm.ImTupleExpr;
23	import de.peeeq.wurstscript.jassIm.ImTupleSelection;
24	import de.peeeq.wurstscript.jassIm.ImVar;
25	import de.peeeq.wurstscript.jassIm.ImVarAccess;
26	import de.peeeq.wurstscript.jassIm.ImVarArrayAccess;
27	import de.peeeq.wurstscript.jassIm.ImVarargLoop;
28	import de.peeeq.wurstscript.translation.imtranslation.purity.Pure;
29	import de.peeeq.wurstscript.types.WurstTypeBool;
30
31	import java.util.ArrayList;
32	import java.util.Arrays;
33	import java.util.Collections;
34	import java.util.List;
35
36	import static de.peeeq.wurstscript.jassIm.JassIm.*;
37
38	/**
39	* flattening expressions and statements
40	* after flattening there will be no more StatementExprs
41	* for expressions there might be a StatementExpr on the top level
42	* <p>
43	* TODO wait, its not that easy: you have to make sure that the execution order is not changed for functions and global variables
44	* <p>
45	* e.g. take
46	* <p>
47	* y = x + StatementExpr(setX(4), 2)
48	* <p>
49	* this should be translated to:
50	* <p>
51	* temp = x
52	* setX(4)
53	* y = temp + 2
54	* <p>
55	* <p>
56	* alternative: relax language semantics
57	*/
58	public class Flatten {	×
59
60
61	public static Result flatten(ImTypeVarDispatch imTypeVarDispatch, ImTranslator translator, ImFunction f) {
62	throw new RuntimeException("called too early");	×
63	}
64
65	public static Result flatten(ImCast imCast, ImTranslator translator, ImFunction f) {
66	Result res = imCast.getExpr().flatten(translator, f);	1✔
67	return new Result(res.stmts, ImCast(res.expr, imCast.getToType()));	1✔
68	}
69
70	public static Result flatten(ImTypeIdOfObj e, ImTranslator translator, ImFunction f) {
71	Result o = e.getObj().flatten(translator, f);	×
72	return new Result(o.stmts, ImTypeIdOfObj(o.expr, e.getClazz()));	×
73	}
74
75	public static Result flatten(ImTypeIdOfClass e, ImTranslator translator, ImFunction f) {
76	e.setParent(null);	×
77	return new Result(e);	×
78	}
79
80	public static Result flatten(ImDealloc d, ImTranslator translator, ImFunction f) {
81	Result o = d.getObj().flatten(translator, f);	1✔
82	return new Result(o.stmts, ImDealloc(d.getTrace(), d.getClazz(), o.expr));	1✔
83	}
84
85	public static Result flatten(ImInstanceof e, ImTranslator translator, ImFunction f) {
86	Result res = e.getObj().flatten(translator, f);	×
87	return new Result(res.stmts, ImInstanceof(res.expr, e.getClazz()));	×
88	}
89
90	public static Result flatten(ImAlloc e, ImTranslator translator, ImFunction f) {
91	e.setParent(null);	1✔
92	return new Result(e);	1✔
93	}
94
95
96	public static class Result {
97
98	List<ImStmt> stmts;
99	final ImExpr expr;
100
101	public Result(List<ImStmt> stmts, ImExpr expr) {	1✔
102	Preconditions.checkArgument(expr.getParent() == null, "expression must not have a parent");	1✔
103	Preconditions.checkArgument(stmts.stream().allMatch(s -> s.getParent() == null), "statement must not have a parent");	1✔
104	this.stmts = stmts;	1✔
105	this.expr = expr;	1✔
106	}	1✔
107
108	public Result(ImExpr expr) {
109	this(Collections.emptyList(), expr);	1✔
110	}	1✔
111
112	public Result(List<ImStmt> stmts) {
113	this(stmts, ImHelper.nullExpr());	1✔
114	}	1✔
115
116	public void intoStatements(List<ImStmt> result, ImTranslator t, ImFunction f) {
117	result.addAll(stmts);	1✔
118	exprToStatements(result, expr, t, f);	1✔
119	}	1✔
120
121	public List<ImStmt> getStmts() {
122	return stmts;	×
123	}
124
125	public ImExpr getExpr() {
126	return expr;	×
127	}
128
129	public ImStatementExpr toStatementExpr() {
130	return JassIm.ImStatementExpr(JassIm.ImStmts(stmts), expr);	×
131	}
132
133	public void addStmts(List<ImStmt> stmts) {
134	if (stmts.isEmpty()) {	1✔
135	return;	1✔
136	}
137	this.stmts = new ArrayList<>(this.stmts);	1✔
138	this.stmts.addAll(stmts);	1✔
139	}	1✔
140	}
141
142	public static class ResultL extends Result {
143	public ResultL(List<ImStmt> stmts, ImLExpr expr) {
144	super(stmts, expr);	1✔
145	}	1✔
146
147	public ResultL(ImLExpr expr) {
148	super(expr);	1✔
149	}	1✔
150
151	@Override
152	public ImLExpr getExpr() {
153	return (ImLExpr) super.getExpr();	×
154	}
155	}
156
157	public static class MultiResult {
158
159	final List<ImStmt> stmts;
160	final List<ImExpr> exprs;
161
162	public MultiResult(List<ImStmt> stmts, List<ImExpr> exprs) {	1✔
163	this.stmts = stmts;	1✔
164	this.exprs = exprs;	1✔
165	}	1✔
166
167
168	public ImExpr expr(int i) {
169	return exprs.get(i);	×
170	}
171
172	}
173
174	public static class MultiResultL extends MultiResult {
175
176	public MultiResultL(List<ImStmt> stmts, List<ImLExpr> exprs) {
177	super(stmts, ImmutableList.copyOf(exprs));	×
178	}	×
179
180	public ImLExpr expr(int i) {
181	return (ImLExpr) super.expr(i);	×
182	}
183
184	public List<ImLExpr> getLExprs() {
185	//noinspection unchecked,rawtypes
186	return (List) exprs;	×
187	}
188
189	}
190
191	private static void exprToStatements(List<ImStmt> result, Element e, ImTranslator t, ImFunction f) {
192	if (e instanceof ImFunctionCall) {	1✔
193	Result res = flatten((ImFunctionCall) e, t, f);	1✔
194	result.addAll(res.stmts);	1✔
195	result.add(res.expr);	1✔
196	} else if (e instanceof ImDealloc) {	1✔
197	Result res = flatten((ImDealloc) e, t, f);	1✔
198	result.addAll(res.stmts);	1✔
199	result.add(res.expr);	1✔
200	} else if (e instanceof ImMethodCall) {	1✔
201	Result res = flatten((ImMethodCall) e, t, f);	1✔
202	result.addAll(res.stmts);	1✔
203	result.add(res.expr);	1✔
204	} else if (e instanceof ImStatementExpr) {	1✔
205	ImStatementExpr e2 = (ImStatementExpr) e;	×
206	flattenStatementsInto(result, e2.getStatements(), t, f);	×
207	exprToStatements(result, e2, t, f);	×
208	} else if (e instanceof ImOperatorCall &&	1✔
209	(((ImOperatorCall) e).getOp() == WurstOperator.AND	1✔
210	\|\| ((ImOperatorCall) e).getOp() == WurstOperator.OR)) {	1✔
211	// short circuiting operators have to be handled in a special way:
212	// we translate them to if statements when necessary
213	ImOperatorCall oc = (ImOperatorCall) e;	1✔
214	ImStmts rightStmts = JassIm.ImStmts();	1✔
215	ImExpr right = oc.getArguments().get(1);	1✔
216	ImExpr left = oc.getArguments().get(0);	1✔
217	exprToStatements(rightStmts, right, t, f);	1✔
218	if (rightStmts.isEmpty()) {	1✔
219	// if no statements for righthand side, then just use left hand side as result
220	exprToStatements(result, left, t, f);	1✔
221	} else {
222	// if righthandside contains some statements, transform the whole thing to an if statement:
223	if (oc.getOp() == WurstOperator.AND) {	1✔
224	result.add(JassIm.ImIf(e.attrTrace(), left.copy(), rightStmts, JassIm.ImStmts()));	1✔
225	} else { // WurstOperator.OR
226	result.add(JassIm.ImIf(e.attrTrace(), left.copy(), JassIm.ImStmts(), rightStmts));	×
227	}
228	}
229	} else {	1✔
230	// visit children:
231	for (int i = 0; i < e.size(); i++) {	1✔
232	exprToStatements(result, e.get(i), t, f);	1✔
233	}
234	}
235	}	1✔
236
237
238	private static ImStmts flattenStatements(ImStmts statements, ImTranslator t, ImFunction f) {
239	ImStmts result = ImStmts();	1✔
240	flattenStatementsInto(result, statements, t, f);	1✔
241	return result;	1✔
242	}
243
244	private static void flattenStatementsInto(List<ImStmt> result, ImStmts statements, ImTranslator t, ImFunction f) {
245	for (ImStmt s : statements) {	1✔
246	s.flatten(t, f).intoStatements(result, t, f);	1✔
247	}	1✔
248	}	1✔
249
250	public static Result flatten(ImExitwhen s, ImTranslator t, ImFunction f) {
251	Result cond = s.getCondition().flatten(t, f);	1✔
252	List<ImStmt> stmts = Lists.newArrayList(cond.stmts);	1✔
253	stmts.add(ImExitwhen(s.getTrace(), cond.expr));	1✔
254	return new Result(stmts);	1✔
255	}
256
257
258	public static Result flatten(ImIf s, ImTranslator t, ImFunction f) {
259	Result cond = s.getCondition().flatten(t, f);	1✔
260	List<ImStmt> stmts = Lists.newArrayList(cond.stmts);	1✔
261	stmts.add(	1✔
262	JassIm.ImIf(s.getTrace(), cond.expr,	1✔
263	flattenStatements(s.getThenBlock(), t, f),	1✔
264	flattenStatements(s.getElseBlock(), t, f)));	1✔
265	return new Result(stmts);	1✔
266	}
267
268
269	public static Result flatten(ImLoop s, ImTranslator t, ImFunction f) {
270	return new Result(Collections.singletonList(	1✔
271	JassIm.ImLoop(s.getTrace(), flattenStatements(s.getBody(), t, f))));	1✔
272	}
273
274	public static Result flatten(ImReturn s, ImTranslator t, ImFunction f) {
275	if (s.getReturnValue() instanceof ImExpr) {	1✔
276	ImExpr ret = (ImExpr) s.getReturnValue();	1✔
277	Result result = ret.flatten(t, f);	1✔
278	List<ImStmt> stmts = Lists.newArrayList(result.stmts);	1✔
279	stmts.add(ImReturn(s.getTrace(), result.expr));	1✔
280	return new Result(stmts);	1✔
281	} else {
282	s.setParent(null);	1✔
283	return new Result(Collections.singletonList(s));	1✔
284	}
285	}
286
287
288	public static Result flatten(ImSet s, ImTranslator t, ImFunction f) {
289	Result l = s.getLeft().flatten(t, f);	1✔
290	Result r = s.getRight().flatten(t, f);	1✔
291	List<ImStmt> stmts = Lists.newArrayList(l.stmts);	1✔
292	stmts.addAll(r.stmts);	1✔
293	stmts.add(JassIm.ImSet(s.getTrace(), (ImLExpr) l.expr, r.expr));	1✔
294	return new Result(stmts);	1✔
295	}
296
297
298	public static Result flatten(ImFunctionCall e, ImTranslator t, ImFunction f) {
299	MultiResult r = flattenExprs(t, f, e.getArguments());	1✔
300	return new Result(r.stmts, ImFunctionCall(e.getTrace(), e.getFunc(), e.getTypeArguments().copy(), ImExprs(r.exprs), e.getTuplesEliminated(), e.getCallType()));	1✔
301	}
302
303	public static Result flatten(ImMethodCall e, ImTranslator t, ImFunction f) {
304	Result recR = e.getReceiver().flatten(t, f);	1✔
305	MultiResult argsR = flattenExprs(t, f, e.getArguments());	1✔
306	Result res = new Result(recR.stmts, ImMethodCall(e.getTrace(), e.getMethod(), e.getTypeArguments().copy(), recR.expr, ImExprs(argsR.exprs), e.getTuplesEliminated()));	1✔
307	res.addStmts(argsR.stmts);	1✔
308	return res;	1✔
309	}
310
311	public static Result flatten(ImOperatorCall e, ImTranslator t, ImFunction f) {
312	// TODO special case and, or
313	de.peeeq.wurstscript.ast.Element trace = e.attrTrace();	1✔
314	switch (e.getOp()) {	1✔
315	case AND: {
316	Result left = e.getArguments().get(0).flatten(t, f);	1✔
317	Result right = e.getArguments().get(1).flatten(t, f);	1✔
318
319	if (right.stmts.isEmpty()) {	1✔
320	return new Result(left.stmts, JassIm.ImOperatorCall(WurstOperator.AND, ImExprs(left.expr, right.expr)));	1✔
321	} else {
322	ArrayList<ImStmt> stmts = Lists.newArrayList(left.stmts);	1✔
323	ImVar tempVar = JassIm.ImVar(e.attrTrace(), WurstTypeBool.instance().imTranslateType(t), "andLeft", false);	1✔
324	f.getLocals().add(tempVar);	1✔
325	ImStmts thenBlock = JassIm.ImStmts();	1✔
326	// if left is true then check right
327	thenBlock.addAll(right.stmts);	1✔
328	thenBlock.add(ImSet(trace, ImVarAccess(tempVar), right.expr));	1✔
329	// else the result is false
330	ImStmts elseBlock = JassIm.ImStmts(ImSet(trace, ImVarAccess(tempVar), JassIm.ImBoolVal(false)));	1✔
331	stmts.add(ImIf(trace, left.expr, thenBlock, elseBlock));	1✔
332	return new Result(stmts, JassIm.ImVarAccess(tempVar));	1✔
333	}
334	}
335	case OR: {
336	Result left = e.getArguments().get(0).flatten(t, f);	1✔
337	Result right = e.getArguments().get(1).flatten(t, f);	1✔
338
339	if (right.stmts.isEmpty()) {	1✔
340	return new Result(left.stmts, JassIm.ImOperatorCall(WurstOperator.OR, ImExprs(left.expr, right.expr)));	1✔
341	} else {
342	ArrayList<ImStmt> stmts = Lists.newArrayList(left.stmts);	1✔
343	ImVar tempVar = JassIm.ImVar(trace, WurstTypeBool.instance().imTranslateType(t), "andLeft", false);	1✔
344	f.getLocals().add(tempVar);	1✔
345	// if left is true then result is ture
346	ImStmts thenBlock = JassIm.ImStmts(ImSet(trace, ImVarAccess(tempVar), JassIm.ImBoolVal(true)));	1✔
347	// else check right
348	ImStmts elseBlock = JassIm.ImStmts();	1✔
349	elseBlock.addAll(right.stmts);	1✔
350	elseBlock.add(ImSet(trace, ImVarAccess(tempVar), right.expr));	1✔
351	stmts.add(ImIf(trace, left.expr, thenBlock, elseBlock));	1✔
352	return new Result(stmts, JassIm.ImVarAccess(tempVar));	1✔
353	}
354	}
355	default:
356	MultiResult r = flattenExprs(t, f, e.getArguments());	1✔
357	return new Result(r.stmts, JassIm.ImOperatorCall(e.getOp(), ImExprs(r.exprs)));	1✔
358	}
359	}
360
361
362	public static Result flatten(ImConst e, ImTranslator t, ImFunction f) {
363	e.setParent(null);	1✔
364	return new Result(e);	1✔
365	}
366
367
368	public static Result flatten(ImStatementExpr e, ImTranslator t, ImFunction f) {
369	List<ImStmt> stmts = Lists.newArrayList();	1✔
370	flattenStatementsInto(stmts, e.getStatements(), t, f);	1✔
371	Result r = e.getExpr().flatten(t, f);	1✔
372	stmts.addAll(r.stmts);	1✔
373	return new Result(stmts, r.expr);	1✔
374	}
375
376	public static ResultL flattenL(ImStatementExpr e, ImTranslator t, ImFunction f) {
377	List<ImStmt> stmts = Lists.newArrayList();	×
378	flattenStatementsInto(stmts, e.getStatements(), t, f);	×
379	ResultL r = ((ImLExpr) e.getExpr()).flattenL(t, f);	×
380	stmts.addAll(r.stmts);	×
381	return new ResultL(stmts, r.getExpr());	×
382	}
383
384
385	public static Result flatten(ImTupleExpr e, ImTranslator t, ImFunction f) {
386	MultiResult r = flattenExprs(t, f, e.getExprs());	1✔
387	return new Result(r.stmts, JassIm.ImTupleExpr(ImExprs(r.exprs)));	1✔
388	}
389
390	public static ResultL flattenL(ImTupleExpr e, ImTranslator t, ImFunction f) {
391	@SuppressWarnings({"unchecked", "rawtypes"})
392	List<ImLExpr> exprs = (List) e.getExprs();	×
393	MultiResultL r = flattenExprsL(t, f, exprs);	×
394	ImExprs newExprs = ImExprs();	×
395	newExprs.addAll(r.getLExprs());	×
396	return new ResultL(r.stmts, JassIm.ImTupleExpr(newExprs));	×
397	}
398
399
400	public static Result flatten(ImTupleSelection e, ImTranslator t, ImFunction f) {
401	return flattenL(e, t, f);	1✔
402	}
403
404	public static ResultL flattenL(ImTupleSelection e, ImTranslator t, ImFunction f) {
405	Result r = e.getTupleExpr().flatten(t, f);	1✔
406	ImLExpr tupleExpr;
407	List<ImStmt> stmts;
408	if (r.expr instanceof ImLExpr) {	1✔
409	tupleExpr = (ImLExpr) r.expr;	1✔
410	stmts = r.stmts;	1✔
411	} else {
412	// in the unlikely event that this is not an l-value (e.g. foo().x)
413	// we create a temporary variable and store the result there
414	ImVar v = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "tuple_temp", false);	×
415	f.getLocals().add(v);	×
416	stmts = new ArrayList<>(r.stmts);	×
417	stmts.add(JassIm.ImSet(e.attrTrace(), ImVarAccess(v), r.expr));	×
418	tupleExpr = JassIm.ImVarAccess(v);	×
419	}
420	return new ResultL(stmts, JassIm.ImTupleSelection(tupleExpr, e.getTupleIndex()));	1✔
421	}
422
423	public static ResultL flattenL(ImVarAccess e, ImTranslator t, ImFunction f) {
424	e.setParent(null);	1✔
425	return new ResultL(e);	1✔
426	}
427
428
429	public static ResultL flatten(ImLExpr e, ImTranslator t, ImFunction f) {
430	return e.flattenL(t, f);	1✔
431	}
432
433	public static ResultL flattenL(ImVarArrayAccess e, ImTranslator t, ImFunction f) {
434	MultiResult indexes = flattenExprs(t, f, e.getIndexes());	1✔
435	return new ResultL(indexes.stmts, ImVarArrayAccess(e.getTrace(), e.getVar(), ImExprs(indexes.exprs)));	1✔
436	}
437
438
439	public static void flattenFunc(ImFunction f, ImTranslator translator) {
440	ImStmts newBody = flattenStatements(f.getBody(), translator, f);	1✔
441	f.setBody(newBody);	1✔
442	}	1✔
443
444	public static void flattenProg(ImProg imProg, ImTranslator translator) {
445	imProg.getFunctions().parallelStream().forEach(f -> f.flatten(translator));	1✔
446	imProg.getClasses().parallelStream().forEach(c ->	1✔
447	c.getFunctions().parallelStream().forEach(f -> f.flatten(translator)));	1✔
448
449	translator.assertProperties(AssertProperty.FLAT);	1✔
450	}	1✔
451
452	public static Result flatten(ImCompiletimeExpr e, ImTranslator translator, ImFunction f) {
453	e.setParent(null);	×
454	return new Result(e);	×
455	}
456
457
458	private static MultiResult flattenExprs(ImTranslator t, ImFunction f, ImExpr... exprs) {
459	return flattenExprs(t, f, Arrays.asList(exprs));	×
460	}
461
462	private static MultiResult flattenExprs(ImTranslator t, ImFunction f, List<ImExpr> exprs) {
463	// TODO optimize this function to use less temporary variables
464	List<ImStmt> stmts = Lists.newArrayList();	1✔
465	List<ImExpr> newExprs = Lists.newArrayList();	1✔
466	List<Result> results = Lists.newArrayList();	1✔
467	int withStmts = -1;	1✔
468	for (int i = 0; i < exprs.size(); i++) {	1✔
469	Result r = exprs.get(i).flatten(t, f);	1✔
470	results.add(r);	1✔
471	if (!r.stmts.isEmpty()) {	1✔
472	withStmts = i;	1✔
473	}
474	}
475	for (int i = 0; i < exprs.size(); i++) {	1✔
476	ImExpr e = exprs.get(i);	1✔
477	Result r = results.get(i);	1✔
478
479	stmts.addAll(r.stmts);	1✔
480	if (r.expr.attrPurity() instanceof Pure	1✔
481	\|\| i >= withStmts) {
482	newExprs.add(r.expr);	1✔
483	} else {
484	ImVar tempVar = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "temp", false);	1✔
485	f.getLocals().add(tempVar);	1✔
486	stmts.add(ImSet(e.attrTrace(), ImVarAccess(tempVar), r.expr));	1✔
487	newExprs.add(JassIm.ImVarAccess(tempVar));	1✔
488	}
489	}
490	return new MultiResult(stmts, newExprs);	1✔
491	}
492
493	private static MultiResultL flattenExprsL(ImTranslator t, ImFunction f, List<ImLExpr> exprs) {
494	// TODO optimize this function to use less temporary variables
495	List<ImStmt> stmts = Lists.newArrayList();	×
496	List<ImLExpr> newExprs = Lists.newArrayList();	×
497	List<ResultL> results = Lists.newArrayList();	×
498	int withStmts = -1;	×
499	for (int i = 0; i < exprs.size(); i++) {	×
500	ResultL r = exprs.get(i).flattenL(t, f);	×
501	results.add(r);	×
502	if (!r.stmts.isEmpty()) {	×
503	withStmts = i;	×
504	}
505	}
506	for (int i = 0; i < exprs.size(); i++) {	×
507	ImExpr e = exprs.get(i);	×
508	ResultL r = results.get(i);	×
509
510	stmts.addAll(r.stmts);	×
511	if (r.expr.attrPurity() instanceof Pure	×
512	\|\| i >= withStmts) {
513	newExprs.add(r.getExpr());	×
514	} else {
515	ImVar tempVar = JassIm.ImVar(e.attrTrace(), r.expr.attrTyp(), "temp", false);	×
516	f.getLocals().add(tempVar);	×
517	stmts.add(ImSet(e.attrTrace(), ImVarAccess(tempVar), r.expr));	×
518	newExprs.add(JassIm.ImVarAccess(tempVar));	×
519	}
520	}
521	return new MultiResultL(stmts, newExprs);	×
522	}
523
524
525	public static Result flatten(ImMemberAccess e,
526	ImTranslator t, ImFunction f) {
527	Result rr = e.getReceiver().flatten(t, f);	1✔
528	MultiResult ir = flattenExprs(t, f, e.getIndexes());	1✔
529	Result res = new Result(rr.stmts, ImMemberAccess(e.getTrace(), rr.expr, e.getTypeArguments().copy(), e.getVar(), ImExprs(ir.exprs)));	1✔
530	res.addStmts(ir.stmts);	1✔
531	return res;	1✔
532	}
533
534	public static ResultL flattenL(ImMemberAccess e,
535	ImTranslator t, ImFunction f) {
536	Result rr = e.getReceiver().flatten(t, f);	×
537	MultiResult ir = flattenExprs(t, f, e.getIndexes());	×
538	ResultL res = new ResultL(rr.stmts, ImMemberAccess(e.getTrace(), rr.expr, e.getTypeArguments(), e.getVar(), ImExprs(ir.exprs)));	×
539	res.addStmts(ir.stmts);	×
540	return res;	×
541	}
542
543
544	public static Result flatten(ImGetStackTrace e, ImTranslator translator,
545	ImFunction f) {
546	e.setParent(null);	1✔
547	return new Result(e);	1✔
548	}
549
550
551	public static Result flatten(ImVarargLoop s, ImTranslator translator, ImFunction f) {
552	return new Result(Collections.singletonList(	1✔
553	JassIm.ImVarargLoop(s.getTrace(), flattenStatements(s.getBody(), translator, f), s.getLoopVar())));	1✔
554	}
555
556
557	}

wurstscript / WurstScript / 220

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous