wurstscript / WurstScript / 271

Committed 29 Sep 2025 12:12PM UTC coverage: 64.649% (+2.4%) from 62.222%

Build # 271

Build Type

Pull #1096

circleci

Committed by

Frotty

Commit Message

Merge branch 'perf-improvements' of https://github.com/wurstscript/WurstScript into perf-improvements

Pull Request Pull Request #1096: Perf improvements

Run Details

18202 of 28155 relevant lines covered (64.65%)

0.65 hits per line

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

81.48

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

package de.peeeq.wurstscript.translation.imtojass;


import de.peeeq.wurstscript.WurstOperator;
import de.peeeq.wurstscript.attributes.CompileError;
import de.peeeq.wurstscript.jassAst.*;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.translation.imtranslation.ImTranslator;
import de.peeeq.wurstscript.types.TypesHelper;

import static de.peeeq.wurstscript.jassAst.JassAst.*;

public class ExprTranslation {

    public static JassExpr translate(ImBoolVal e, ImToJassTranslator translator) {
        return JassAst.JassExprBoolVal(e.getValB());
    }

    public static JassExpr translate(ImFuncRef e, ImToJassTranslator translator) {
        JassFunctionOrNative f = translator.getJassFuncFor(e.getFunc());
        return JassAst.JassExprFuncRef(f.getName());
    }

    public static JassExpr translate(ImFunctionCall e, ImToJassTranslator translator) {

        JassFunctionOrNative f = translator.getJassFuncFor(e.getFunc());
        JassExprlist arguments = JassExprlist();
        for (ImExpr arg : e.getArguments()) {
            arguments.add(arg.translate(translator));
        }
        String funcName = f.getName();
        if (funcName.equals(ImTranslator.$DEBUG_PRINT)) {
            funcName = "BJDebugMsg";
        }
        switch (e.getCallType()) {
            case NORMAL:
                return JassAst.JassExprFunctionCall(funcName, arguments);
            case EXECUTE:
                return JassAst.JassExprFunctionCall("ExecuteFunc", JassAst.JassExprlist(JassAst.JassExprStringVal(f.getName())));
            default:
                throw new Error("unhandled case");
        }
    }

    public static JassExpr translate(ImIntVal e, ImToJassTranslator translator) {
        return JassExprIntVal(String.valueOf(e.getValI()));
    }

    public static JassExpr translate(ImNull e, ImToJassTranslator translator) {
        if (e.getType() instanceof ImAnyType
            || TypesHelper.isIntType(e.getType())) {
            return JassExprIntVal("0");
        }
        return JassExprNull();
    }

    public static JassExpr translate(ImOperatorCall e, ImToJassTranslator translator) {
        WurstOperator op = e.getOp();
        if (op.isBinaryOp() && e.getArguments().size() == 2) {
            JassExpr left = e.getArguments().get(0).translate(translator);
            JassExpr right = e.getArguments().get(1).translate(translator);

            if (op == WurstOperator.PLUS) {
                // special cases for using 'null' as a string constant:
                // "a" + null gets translated to just "a"
                if (left instanceof JassExprNull) {
                    return right;
                }
                if (right instanceof JassExprNull) {
                    return left;
                }
            }

            if (op == WurstOperator.MOD_REAL) {
                return JassExprFunctionCall("ModuloReal", JassExprlist(left, right));
            } else if (op == WurstOperator.MOD_INT) {
                return JassExprFunctionCall("ModuloInteger", JassExprlist(left, right));
            }

            return JassExprBinary(left, op.jassTranslateBinary(), right);
        } else if (op.isUnaryOp() && e.getArguments().size() == 1) {
            return JassExprUnary(op.jassTranslateUnary(), e.getArguments().get(0).translate(translator));
        } else {
            throw new Error("not implemented: " + e);
        }
    }


    public static JassExpr translate(ImRealVal e, ImToJassTranslator translator) {
        return JassExprRealVal(e.getValR());
    }

    public static JassExpr translate(ImStatementExpr e, ImToJassTranslator translator) {
        throw new Error("this expr should have been flattened: " + e + "\n\n" + e.getNearestFunc());
    }

    public static JassExpr translate(ImStringVal e, ImToJassTranslator translator) {
        return JassExprStringVal(e.getValS());
    }

    public static JassExpr translate(ImTupleExpr e, ImToJassTranslator translator) {
        throw new Error("tuples should be eliminated in this phase");
    }

    public static JassExpr translate(ImTupleSelection e, ImToJassTranslator translator) {
        throw new Error("tuples should be eliminated in this phase");
    }

    public static JassExprVarAccess translate(ImVarAccess e, ImToJassTranslator translator) {
        JassVar v = translator.getJassVarFor(e.getVar());
        return JassExprVarAccess(v.getName());
    }

    public static JassExprVarArrayAccess translate(ImVarArrayAccess e, ImToJassTranslator translator) {
        JassVar v = translator.getJassVarFor(e.getVar());
        if (e.getIndexes().size() != 1) {
            throw new CompileError(e.attrTrace().attrSource(), "Only one array index allowed.");
        }
        return JassExprVarArrayAccess(v.getName(), e.getIndexes().get(0).translate(translator));
    }

    public static JassExpr translate(ImClassRelatedExpr e,
                                     ImToJassTranslator translator) {
        throw new RuntimeException("Eliminate method calls before translating to jass:\n" + e);
    }


    public static JassExpr translate(ImGetStackTrace imGetStackTrace, ImToJassTranslator translator) {
        return JassAst.JassExprStringVal("");
    }


    public static JassExpr translate(ImCompiletimeExpr e, ImToJassTranslator translator) {
        throw new CompileError(e.attrTrace().attrSource(),
                "Compiletime expression must be evaluated before translation. " +
                "Enable '-runcompiletimefunctions' to evaluate compiletime expressions.");
    }

    public static JassExpr translate(ImTypeVarDispatch e, ImToJassTranslator translator) {
        throw new CompileError(e, "Typevar dispatch not eliminated.");
    }

    public static JassExpr translate(ImCast imCast, ImToJassTranslator translator) {
        return imCast.getExpr().translate(translator);
    }
}

1	package de.peeeq.wurstscript.translation.imtojass;
2
3
4	import de.peeeq.wurstscript.WurstOperator;
5	import de.peeeq.wurstscript.attributes.CompileError;
6	import de.peeeq.wurstscript.jassAst.*;
7	import de.peeeq.wurstscript.jassIm.*;
8	import de.peeeq.wurstscript.translation.imtranslation.ImTranslator;
9	import de.peeeq.wurstscript.types.TypesHelper;
10
11	import static de.peeeq.wurstscript.jassAst.JassAst.*;
12
13	public class ExprTranslation {	×
14
15	public static JassExpr translate(ImBoolVal e, ImToJassTranslator translator) {
16	return JassAst.JassExprBoolVal(e.getValB());	1✔
17	}
18
19	public static JassExpr translate(ImFuncRef e, ImToJassTranslator translator) {
20	JassFunctionOrNative f = translator.getJassFuncFor(e.getFunc());	1✔
21	return JassAst.JassExprFuncRef(f.getName());	1✔
22	}
23
24	public static JassExpr translate(ImFunctionCall e, ImToJassTranslator translator) {
25
26	JassFunctionOrNative f = translator.getJassFuncFor(e.getFunc());	1✔
27	JassExprlist arguments = JassExprlist();	1✔
28	for (ImExpr arg : e.getArguments()) {	1✔
29	arguments.add(arg.translate(translator));	1✔
30	}	1✔
31	String funcName = f.getName();	1✔
32	if (funcName.equals(ImTranslator.$DEBUG_PRINT)) {	1✔
33	funcName = "BJDebugMsg";	1✔
34	}
35	switch (e.getCallType()) {	1✔
36	case NORMAL:
37	return JassAst.JassExprFunctionCall(funcName, arguments);	1✔
38	case EXECUTE:
39	return JassAst.JassExprFunctionCall("ExecuteFunc", JassAst.JassExprlist(JassAst.JassExprStringVal(f.getName())));	1✔
40	default:
41	throw new Error("unhandled case");	×
42	}
43	}
44
45	public static JassExpr translate(ImIntVal e, ImToJassTranslator translator) {
46	return JassExprIntVal(String.valueOf(e.getValI()));	1✔
47	}
48
49	public static JassExpr translate(ImNull e, ImToJassTranslator translator) {
50	if (e.getType() instanceof ImAnyType	1✔
51	\|\| TypesHelper.isIntType(e.getType())) {	1✔
52	return JassExprIntVal("0");	1✔
53	}
54	return JassExprNull();	1✔
55	}
56
57	public static JassExpr translate(ImOperatorCall e, ImToJassTranslator translator) {
58	WurstOperator op = e.getOp();	1✔
59	if (op.isBinaryOp() && e.getArguments().size() == 2) {	1✔
60	JassExpr left = e.getArguments().get(0).translate(translator);	1✔
61	JassExpr right = e.getArguments().get(1).translate(translator);	1✔
62
63	if (op == WurstOperator.PLUS) {	1✔
64	// special cases for using 'null' as a string constant:
65	// "a" + null gets translated to just "a"
66	if (left instanceof JassExprNull) {	1✔
67	return right;	1✔
68	}
69	if (right instanceof JassExprNull) {	1✔
70	return left;	1✔
71	}
72	}
73
74	if (op == WurstOperator.MOD_REAL) {	1✔
75	return JassExprFunctionCall("ModuloReal", JassExprlist(left, right));	1✔
76	} else if (op == WurstOperator.MOD_INT) {	1✔
77	return JassExprFunctionCall("ModuloInteger", JassExprlist(left, right));	1✔
78	}
79
80	return JassExprBinary(left, op.jassTranslateBinary(), right);	1✔
81	} else if (op.isUnaryOp() && e.getArguments().size() == 1) {	1✔
82	return JassExprUnary(op.jassTranslateUnary(), e.getArguments().get(0).translate(translator));	1✔
83	} else {
84	throw new Error("not implemented: " + e);	×
85	}
86	}
87
88
89	public static JassExpr translate(ImRealVal e, ImToJassTranslator translator) {
90	return JassExprRealVal(e.getValR());	1✔
91	}
92
93	public static JassExpr translate(ImStatementExpr e, ImToJassTranslator translator) {
94	throw new Error("this expr should have been flattened: " + e + "\n\n" + e.getNearestFunc());	×
95	}
96
97	public static JassExpr translate(ImStringVal e, ImToJassTranslator translator) {
98	return JassExprStringVal(e.getValS());	1✔
99	}
100
101	public static JassExpr translate(ImTupleExpr e, ImToJassTranslator translator) {
102	throw new Error("tuples should be eliminated in this phase");	×
103	}
104
105	public static JassExpr translate(ImTupleSelection e, ImToJassTranslator translator) {
106	throw new Error("tuples should be eliminated in this phase");	×
107	}
108
109	public static JassExprVarAccess translate(ImVarAccess e, ImToJassTranslator translator) {
110	JassVar v = translator.getJassVarFor(e.getVar());	1✔
111	return JassExprVarAccess(v.getName());	1✔
112	}
113
114	public static JassExprVarArrayAccess translate(ImVarArrayAccess e, ImToJassTranslator translator) {
115	JassVar v = translator.getJassVarFor(e.getVar());	1✔
116	if (e.getIndexes().size() != 1) {	1✔
117	throw new CompileError(e.attrTrace().attrSource(), "Only one array index allowed.");	×
118	}
119	return JassExprVarArrayAccess(v.getName(), e.getIndexes().get(0).translate(translator));	1✔
120	}
121
122	public static JassExpr translate(ImClassRelatedExpr e,
123	ImToJassTranslator translator) {
124	throw new RuntimeException("Eliminate method calls before translating to jass:\n" + e);	×
125	}
126
127
128	public static JassExpr translate(ImGetStackTrace imGetStackTrace, ImToJassTranslator translator) {
129	return JassAst.JassExprStringVal("");	1✔
130	}
131
132
133	public static JassExpr translate(ImCompiletimeExpr e, ImToJassTranslator translator) {
134	throw new CompileError(e.attrTrace().attrSource(),	×
135	"Compiletime expression must be evaluated before translation. " +
136	"Enable '-runcompiletimefunctions' to evaluate compiletime expressions.");
137	}
138
139	public static JassExpr translate(ImTypeVarDispatch e, ImToJassTranslator translator) {
140	throw new CompileError(e, "Typevar dispatch not eliminated.");	×
141	}
142
143	public static JassExpr translate(ImCast imCast, ImToJassTranslator translator) {
144	return imCast.getExpr().translate(translator);	1✔
145	}
146	}

wurstscript / WurstScript / 271

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