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

91.67

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

package de.peeeq.wurstscript.translation.imtojass;

import de.peeeq.wurstscript.jassAst.*;
import de.peeeq.wurstscript.jassIm.*;

import java.util.List;

import static de.peeeq.wurstscript.jassAst.JassAst.*;
public class StatementTranslation {


    public static void translate(ImExitwhen imExitwhen, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        stmts.add(JassStmtExitwhen(imExitwhen.getCondition().translate(translator)));
    }

    public static void translate(ImIf imIf, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        JassExpr cond = imIf.getCondition().translate(translator);
        JassStatements thenBlock = JassStatements();
        imIf.getThenBlock().translate(thenBlock, f, translator);
        JassStatements elseBlock = JassStatements();
        imIf.getElseBlock().translate(elseBlock, f, translator);
        stmts.add(JassStmtIf(cond, thenBlock, elseBlock));
    }


    public static void translate(ImLoop imLoop, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        JassStatements body = JassStatements();
        imLoop.getBody().translate(body, f, translator);
        stmts.add(JassStmtLoop(body));
    }

    public static void translate(ImReturn imReturn, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        if (imReturn.getReturnValue() instanceof ImNoExpr) {
            stmts.add(JassStmtReturnVoid());
        } else {
            ImExpr e = (ImExpr) imReturn.getReturnValue();
            JassExpr returnValue = e.translate(translator);
            stmts.add(JassStmtReturn(returnValue));
        }
    }

    public static void translate(ImSet imSet, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        ImLExpr updatedExpr = imSet.getLeft();
        if (updatedExpr instanceof ImVarAccess) {
            ImVarAccess va = (ImVarAccess) updatedExpr;
            JassVar var = translator.getJassVarFor(va.getVar());
            JassExpr exprs = imSet.getRight().translate(translator);
            stmts.add(JassStmtSet(var.getName(), exprs));
        } else if (updatedExpr instanceof ImVarArrayAccess) {
            ImVarArrayAccess vaa = (ImVarArrayAccess) updatedExpr;
            JassVar var = translator.getJassVarFor(vaa.getVar());
            JassExpr indexes = vaa.getIndexes().get(0).translate(translator);
            JassExpr exprs = imSet.getRight().translate(translator);
            stmts.add(JassStmtSetArray(var.getName(), indexes, exprs));
        }
    }

    public static void translate(ImExpr imExpr, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        JassExpr expr = imExpr.translate(translator);
        // only add the function calls from this expression, the rest can not have any side effects
        addAllCalls(stmts, expr);
    }


    private static void addAllCalls(List<JassStatement> stmts, de.peeeq.wurstscript.jassAst.Element expr) {
        if (expr instanceof JassExprFunctionCall) {
            JassExprFunctionCall fc = (JassExprFunctionCall) expr;
            stmts.add(JassAst.JassStmtCall(fc.getFuncName(), fc.getArguments().copy()));
        } else {
            // visit children
            for (int i = 0; i < expr.size(); i++) {
                addAllCalls(stmts, expr.get(i));
            }
        }
    }


    public static void translate(ImStmts imStmts, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        for (ImStmt s : imStmts) {
            s.translate(stmts, f, translator);
        }
    }


    public static void translate(ImVarargLoop imVarargLoop, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
        throw new Error("not implemented");
    }

}

1	package de.peeeq.wurstscript.translation.imtojass;
2
3	import de.peeeq.wurstscript.jassAst.*;
4	import de.peeeq.wurstscript.jassIm.*;
5
6	import java.util.List;
7
8	import static de.peeeq.wurstscript.jassAst.JassAst.*;
9	public class StatementTranslation {	×
10
11
12	public static void translate(ImExitwhen imExitwhen, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
13	stmts.add(JassStmtExitwhen(imExitwhen.getCondition().translate(translator)));	1✔
14	}	1✔
15
16	public static void translate(ImIf imIf, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
17	JassExpr cond = imIf.getCondition().translate(translator);	1✔
18	JassStatements thenBlock = JassStatements();	1✔
19	imIf.getThenBlock().translate(thenBlock, f, translator);	1✔
20	JassStatements elseBlock = JassStatements();	1✔
21	imIf.getElseBlock().translate(elseBlock, f, translator);	1✔
22	stmts.add(JassStmtIf(cond, thenBlock, elseBlock));	1✔
23	}	1✔
24
25
26	public static void translate(ImLoop imLoop, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
27	JassStatements body = JassStatements();	1✔
28	imLoop.getBody().translate(body, f, translator);	1✔
29	stmts.add(JassStmtLoop(body));	1✔
30	}	1✔
31
32	public static void translate(ImReturn imReturn, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
33	if (imReturn.getReturnValue() instanceof ImNoExpr) {	1✔
34	stmts.add(JassStmtReturnVoid());	1✔
35	} else {
36	ImExpr e = (ImExpr) imReturn.getReturnValue();	1✔
37	JassExpr returnValue = e.translate(translator);	1✔
38	stmts.add(JassStmtReturn(returnValue));	1✔
39	}
40	}	1✔
41
42	public static void translate(ImSet imSet, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
43	ImLExpr updatedExpr = imSet.getLeft();	1✔
44	if (updatedExpr instanceof ImVarAccess) {	1✔
45	ImVarAccess va = (ImVarAccess) updatedExpr;	1✔
46	JassVar var = translator.getJassVarFor(va.getVar());	1✔
47	JassExpr exprs = imSet.getRight().translate(translator);	1✔
48	stmts.add(JassStmtSet(var.getName(), exprs));	1✔
49	} else if (updatedExpr instanceof ImVarArrayAccess) {	1✔
50	ImVarArrayAccess vaa = (ImVarArrayAccess) updatedExpr;	1✔
51	JassVar var = translator.getJassVarFor(vaa.getVar());	1✔
52	JassExpr indexes = vaa.getIndexes().get(0).translate(translator);	1✔
53	JassExpr exprs = imSet.getRight().translate(translator);	1✔
54	stmts.add(JassStmtSetArray(var.getName(), indexes, exprs));	1✔
55	}
56	}	1✔
57
58	public static void translate(ImExpr imExpr, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
59	JassExpr expr = imExpr.translate(translator);	1✔
60	// only add the function calls from this expression, the rest can not have any side effects
61	addAllCalls(stmts, expr);	1✔
62	}	1✔
63
64
65	private static void addAllCalls(List<JassStatement> stmts, de.peeeq.wurstscript.jassAst.Element expr) {
66	if (expr instanceof JassExprFunctionCall) {	1✔
67	JassExprFunctionCall fc = (JassExprFunctionCall) expr;	1✔
68	stmts.add(JassAst.JassStmtCall(fc.getFuncName(), fc.getArguments().copy()));	1✔
69	} else {	1✔
70	// visit children
71	for (int i = 0; i < expr.size(); i++) {	×
72	addAllCalls(stmts, expr.get(i));	×
73	}
74	}
75	}	1✔
76
77
78	public static void translate(ImStmts imStmts, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
79	for (ImStmt s : imStmts) {	1✔
80	s.translate(stmts, f, translator);	1✔
81	}	1✔
82	}	1✔
83
84
85	public static void translate(ImVarargLoop imVarargLoop, List<JassStatement> stmts, JassFunction f, ImToJassTranslator translator) {
86	throw new Error("not implemented");	×
87	}
88
89	}

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