wurstscript / WurstScript / 203

Committed 18 Oct 2023 02:20PM UTC coverage: 63.758% (+0.3%) from 63.447%

Build # 203

Build Type

push

circleci

Committed by

web-flow

Commit Message

Update deps, improve performance, JHCR fixes (#1080)

- update dependencies
- update stdlib verison for unit tests
- only apply nullsetting when `-opt` is enabled to save some build time for testing
- minor performance improvements
- make build deterministic
- apply build map config before compilation
- hot code reload now more reliable

Run Details

17246 of 27049 relevant lines covered (63.76%)

0.64 hits per line

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

0.0

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

package de.peeeq.wurstscript.translation.imoptimizer;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
import de.peeeq.wurstscript.translation.imtranslation.ImTranslator;

import java.util.List;
import java.util.Set;

/**
 * sets local handle variables to null at every return statement
 */
public class NullSetter {


    private ImProg prog;
    private ImTranslator translator;

    // the types which are not set to null
    private Set<String> primitiveTypes = Sets.newHashSet("boolean", "integer", "string", "code", "real");

    public NullSetter(ImTranslator translator) {
        this.translator = translator;
        this.prog = translator.getImProg();
    }

    public void optimize() {
        prog.flatten(translator);
        for (ImFunction f : ImHelper.calculateFunctionsOfProg(prog)) {
            optimizeFunc(f);
        }

    }

    private void optimizeFunc(final ImFunction f) {
        if (f.isBj() || f.isNative() || f.isCompiletime() || f.isExtern()) {
            return;
        }
        final List<ImVar> handleVars = Lists.newArrayList();
        for (ImVar local : f.getLocals()) {
            if (isHandleType(local.getType())) {
                handleVars.add(local);
            }
        }
        if (handleVars.isEmpty()) {
            // functions without handle vars can be skipped
            return;
        }
        final List<ImStmt> nullSetStmts = Lists.newArrayList();
        final de.peeeq.wurstscript.ast.Element trace = f.getTrace();
        for (ImVar local : handleVars) {
            nullSetStmts.add(JassIm.ImSet(trace, JassIm.ImVarAccess(local), JassIm.ImNull(local.getType())));
        }
        boolean returns = optimizeChildren(f, handleVars, nullSetStmts, trace, f.getBody());

        if (!returns) {
            // add null set statements if not alreay returned ...
            addNullSetStmts(f.getBody(), f.getBody().size(), nullSetStmts);
        }
    }

    /**
     * adds nullSetStmts in front of every return statement
     * <p>
     * returns true if "parent" always returns
     *
     * @param f
     * @param handleVars
     * @param nullSetStmts
     * @param trace
     * @param parent
     * @return
     */
    private boolean optimizeChildren(final ImFunction f,
                                     final List<ImVar> handleVars, final List<ImStmt> nullSetStmts,
                                     final de.peeeq.wurstscript.ast.Element trace, Element parent) {
        for (int i = 0; i < parent.size(); i++) {
            Element elem = parent.get(i);
            if (elem instanceof ImReturn) {
                handleReturnStmt(f, handleVars, nullSetStmts, trace, (ImReturn) elem);
                return true;
            } else if (elem instanceof ImIf) {
                ImIf imIf = (ImIf) elem;
                boolean returnsThen = optimizeChildren(f, handleVars, nullSetStmts, trace, imIf.getThenBlock());
                boolean returnsElse = optimizeChildren(f, handleVars, nullSetStmts, trace, imIf.getElseBlock());
                if (returnsThen && returnsElse) {
                    return true;
                }
            } else if (elem instanceof ImLoop) {
                optimizeChildren(f, handleVars, nullSetStmts, trace, elem);
                // simplifying assumption: loops never return always
            } else {
                // visit children
                boolean returns = optimizeChildren(f, handleVars, nullSetStmts, trace, elem);
                if (returns) {
                    return true;
                }
            }
        }
        return false;
    }

    private void handleReturnStmt(final ImFunction f,
                                  final List<ImVar> handleVars, final List<ImStmt> nullSetStmts,
                                  final de.peeeq.wurstscript.ast.Element trace, ImReturn imReturn) {
        ImStmts parent2 = (ImStmts) imReturn.getParent();
        int parentIndex = parent2.indexOf(imReturn);
        if (imReturn.getReturnValue() instanceof ImExpr) { // returns some value
            ImExpr returnExpr = (ImExpr) imReturn.getReturnValue();

            addNullSetStmts(parent2, parentIndex, nullSetStmts);

            if (exprContainsVar(returnExpr, handleVars)) {
                // if the returnExpr contains some handleVar, we have to add a temporary var

                ImVar tempReturn = JassIm.ImVar(imReturn.attrTrace(), returnExpr.attrTyp(), f.getName() + "tempReturn", false);
                if (isHandleType(returnExpr.attrTyp())) {
                    // use global variables for handle types
                    prog.getGlobals().add(tempReturn);
                } else {
                    // local variables for other types
                    f.getLocals().add(tempReturn);
                }

                imReturn.setReturnValue(JassIm.ImVarAccess(tempReturn));
                parent2.add(parentIndex, JassIm.ImSet(trace, JassIm.ImVarAccess(tempReturn), returnExpr));
            }

        } else { // normal return

            addNullSetStmts(parent2, parentIndex, nullSetStmts);
        }
    }

    private boolean exprContainsVar(ImExpr returnExpr, final List<ImVar> handleVars) {
        final boolean[] result = {false};
        returnExpr.accept(new ImExpr.DefaultVisitor() {
            @Override
            public void visit(ImVarAccess e) {
                super.visit(e);
                if (handleVars.contains(e.getVar())) {
                    result[0] = true;
                }
            }

        });
        return result[0];
    }

    private void addNullSetStmts(ImStmts parent, int parentIndex,
                                 List<ImStmt> nullSetStmts) {
        List<ImStmt> nullSetStmtsCopy = Lists.newArrayListWithCapacity(nullSetStmts.size());
        for (ImStmt s : nullSetStmts) {
            nullSetStmtsCopy.add((ImStmt) s.copy());
        }
        parent.addAll(parentIndex, nullSetStmtsCopy);
    }

    private boolean isHandleType(ImType type) {
        if (type instanceof ImSimpleType) {
            ImSimpleType imSimpleType = (ImSimpleType) type;
            return !primitiveTypes.contains(imSimpleType.getTypename());
        }
        return false;
    }


}

1	package de.peeeq.wurstscript.translation.imoptimizer;
2
3	import com.google.common.collect.Lists;
4	import com.google.common.collect.Sets;
5	import de.peeeq.wurstscript.jassIm.*;
6	import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
7	import de.peeeq.wurstscript.translation.imtranslation.ImTranslator;
8
9	import java.util.List;
10	import java.util.Set;
11
12	/**
13	* sets local handle variables to null at every return statement
14	*/
15	public class NullSetter {
16
17
18	private ImProg prog;
19	private ImTranslator translator;
20
21	// the types which are not set to null
22	private Set<String> primitiveTypes = Sets.newHashSet("boolean", "integer", "string", "code", "real");	×
23
24	public NullSetter(ImTranslator translator) {	×
25	this.translator = translator;	×
26	this.prog = translator.getImProg();	×
27	}	×
28
29	public void optimize() {
30	prog.flatten(translator);	×
31	for (ImFunction f : ImHelper.calculateFunctionsOfProg(prog)) {	×
32	optimizeFunc(f);	×
33	}	×
34
35	}	×
36
37	private void optimizeFunc(final ImFunction f) {
38	if (f.isBj() \|\| f.isNative() \|\| f.isCompiletime() \|\| f.isExtern()) {	×
39	return;	×
40	}
41	final List<ImVar> handleVars = Lists.newArrayList();	×
42	for (ImVar local : f.getLocals()) {	×
43	if (isHandleType(local.getType())) {	×
44	handleVars.add(local);	×
45	}
46	}	×
47	if (handleVars.isEmpty()) {	×
48	// functions without handle vars can be skipped
49	return;	×
50	}
51	final List<ImStmt> nullSetStmts = Lists.newArrayList();	×
52	final de.peeeq.wurstscript.ast.Element trace = f.getTrace();	×
53	for (ImVar local : handleVars) {	×
54	nullSetStmts.add(JassIm.ImSet(trace, JassIm.ImVarAccess(local), JassIm.ImNull(local.getType())));	×
55	}	×
56	boolean returns = optimizeChildren(f, handleVars, nullSetStmts, trace, f.getBody());	×
57
58	if (!returns) {	×
59	// add null set statements if not alreay returned ...
60	addNullSetStmts(f.getBody(), f.getBody().size(), nullSetStmts);	×
61	}
62	}	×
63
64	/**
65	* adds nullSetStmts in front of every return statement
66	* <p>
67	* returns true if "parent" always returns
68	*
69	* @param f
70	* @param handleVars
71	* @param nullSetStmts
72	* @param trace
73	* @param parent
74	* @return
75	*/
76	private boolean optimizeChildren(final ImFunction f,
77	final List<ImVar> handleVars, final List<ImStmt> nullSetStmts,
78	final de.peeeq.wurstscript.ast.Element trace, Element parent) {
79	for (int i = 0; i < parent.size(); i++) {	×
80	Element elem = parent.get(i);	×
81	if (elem instanceof ImReturn) {	×
82	handleReturnStmt(f, handleVars, nullSetStmts, trace, (ImReturn) elem);	×
83	return true;	×
84	} else if (elem instanceof ImIf) {	×
85	ImIf imIf = (ImIf) elem;	×
86	boolean returnsThen = optimizeChildren(f, handleVars, nullSetStmts, trace, imIf.getThenBlock());	×
87	boolean returnsElse = optimizeChildren(f, handleVars, nullSetStmts, trace, imIf.getElseBlock());	×
88	if (returnsThen && returnsElse) {	×
89	return true;	×
90	}
91	} else if (elem instanceof ImLoop) {	×
92	optimizeChildren(f, handleVars, nullSetStmts, trace, elem);	×
93	// simplifying assumption: loops never return always
94	} else {
95	// visit children
96	boolean returns = optimizeChildren(f, handleVars, nullSetStmts, trace, elem);	×
97	if (returns) {	×
98	return true;	×
99	}
100	}
101	}
102	return false;	×
103	}
104
105	private void handleReturnStmt(final ImFunction f,
106	final List<ImVar> handleVars, final List<ImStmt> nullSetStmts,
107	final de.peeeq.wurstscript.ast.Element trace, ImReturn imReturn) {
108	ImStmts parent2 = (ImStmts) imReturn.getParent();	×
109	int parentIndex = parent2.indexOf(imReturn);	×
110	if (imReturn.getReturnValue() instanceof ImExpr) { // returns some value	×
111	ImExpr returnExpr = (ImExpr) imReturn.getReturnValue();	×
112
113	addNullSetStmts(parent2, parentIndex, nullSetStmts);	×
114
115	if (exprContainsVar(returnExpr, handleVars)) {	×
116	// if the returnExpr contains some handleVar, we have to add a temporary var
117
118	ImVar tempReturn = JassIm.ImVar(imReturn.attrTrace(), returnExpr.attrTyp(), f.getName() + "tempReturn", false);	×
119	if (isHandleType(returnExpr.attrTyp())) {	×
120	// use global variables for handle types
121	prog.getGlobals().add(tempReturn);	×
122	} else {
123	// local variables for other types
124	f.getLocals().add(tempReturn);	×
125	}
126
127	imReturn.setReturnValue(JassIm.ImVarAccess(tempReturn));	×
128	parent2.add(parentIndex, JassIm.ImSet(trace, JassIm.ImVarAccess(tempReturn), returnExpr));	×
129	}
130
131	} else { // normal return	×
132
133	addNullSetStmts(parent2, parentIndex, nullSetStmts);	×
134	}
135	}	×
136
137	private boolean exprContainsVar(ImExpr returnExpr, final List<ImVar> handleVars) {
138	final boolean[] result = {false};	×
139	returnExpr.accept(new ImExpr.DefaultVisitor() {	×
140	@Override
141	public void visit(ImVarAccess e) {
142	super.visit(e);	×
143	if (handleVars.contains(e.getVar())) {	×
144	result[0] = true;	×
145	}
146	}	×
147
148	});
149	return result[0];	×
150	}
151
152	private void addNullSetStmts(ImStmts parent, int parentIndex,
153	List<ImStmt> nullSetStmts) {
154	List<ImStmt> nullSetStmtsCopy = Lists.newArrayListWithCapacity(nullSetStmts.size());	×
155	for (ImStmt s : nullSetStmts) {	×
156	nullSetStmtsCopy.add((ImStmt) s.copy());	×
157	}	×
158	parent.addAll(parentIndex, nullSetStmtsCopy);	×
159	}	×
160
161	private boolean isHandleType(ImType type) {
162	if (type instanceof ImSimpleType) {	×
163	ImSimpleType imSimpleType = (ImSimpleType) type;	×
164	return !primitiveTypes.contains(imSimpleType.getTypename());	×
165	}
166	return false;	×
167	}
168
169
170	}

wurstscript / WurstScript / 203

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