1005

pending completion

Build # 1005

Build Type

Pull #822

travis-ci

Committed by

web-flow

Commit Message

more new bug fixes

Pull Request Pull Request #822: WIP: support for persisting objects in compiletime expressions

Run Details

14931 of 24379 relevant lines covered (61.25%)

0.61 hits per line

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

87.47

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

package de.peeeq.wurstscript.translation.imtranslation;

import de.peeeq.wurstscript.jassIm.*;

import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;

public class ImPrinter {


    public static void print(ImProg p, Appendable sb, int indent) {
        for (ImVar g : p.getGlobals()) {
            g.print(sb, indent);
            append(sb, "\n");
        }
        append(sb, "\n\n");
        p.getGlobalInits().forEach((v,es) -> {
            append(sb, v.getName());
            append(sb, " = ");
            boolean first = true;
            for (ImExpr e : es) {
                if (!first) {
                    append(sb, ", ");
                }
                e.print(sb, indent);
                first = false;
            }
            append(sb, "\n");
        });
        append(sb, "\n\n");
        for (ImFunction f : p.getFunctions()) {
            f.print(sb, indent);
            append(sb, "\n");
        }
        for (ImMethod m : p.getMethods()) {
            printMethod(sb, m, indent);
        }
        append(sb, "\n\n");
        for (ImClass c : p.getClasses()) {
            print(c, sb, indent);
        }

    }

    public static void print(ImClass c, Appendable sb, int indent) {
        append(sb, "class ");
        append(sb, c.getName());
        append(sb, smallHash(c));
        printTypeVariables(c.getTypeVariables(), sb, indent);
        append(sb, " extends ");
        for (ImClassType sc : c.getSuperClasses()) {
            sc.print(sb, indent);
            append(sb, " ");
        }
        append(sb, "{\n");
        for (ImVar f : c.getFields()) {
            indent(sb, indent + 1);
            f.print(sb, indent + 1);
            append(sb, "\n");
        }
        append(sb, "\n\n");
        for (ImMethod m : c.getMethods()) {
            indent(sb, indent + 1);
            printMethod(sb, m, indent + 1);
        }

        for (ImFunction func : c.getFunctions()) {
            func.print(sb, indent + 1);
        }

        append(sb, "}\n\n");
    }

    private static void printMethod(Appendable sb, ImMethod m, int indent) {
        if (m.getIsAbstract()) {
            append(sb, "abstract ");
        }
        append(sb, "method ");
        m.getMethodClass().print(sb, indent);
        append(sb, ".");
        append(sb, m.getName());
        append(sb, smallHash(m));
        append(sb, " implemented by ");
        append(sb, m.getImplementation().getName());
        append(sb, smallHash(m.getImplementation()));
        append(sb, "\n");
        for (ImMethod sm : m.getSubMethods()) {
            append(sb, "        sub: ");
            sm.getMethodClass().print(sb, indent);
            append(sb, ".");
            append(sb, sm.getName());
            append(sb, smallHash(sm));
            append(sb, "\n");
        }
        append(sb, "\n");
    }


    private static void append(Appendable sb, Object s) {
        append(sb, s.toString());
    }

    private static void append(Appendable sb, String s) {
        try {
            sb.append(s);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    public static void print(ImSimpleType p, Appendable sb, int indent) {
        append(sb, p.getTypename());
    }

    public static void print(ImArrayType t, Appendable sb, int indent) {
        append(sb, "array<");
        t.getEntryType().print(sb, indent);
        append(sb, ">");
    }

    public static void print(ImTupleType p, Appendable sb, int indent) {
        append(sb, "⦅");
        boolean first = true;
        for (ImType t : p.getTypes()) {
            if (!first) append(sb, ", ");
            t.print(sb, indent);
            first = false;
        }
        append(sb, "⦆");
    }

    public static void print(ImVoid p, Appendable sb, int indent) {
        append(sb, "void");
    }

    public static void print(ImFunction p, Appendable sb, int indent) {
        indent(sb, indent);
        for (FunctionFlag flag : p.getFlags()) {
            append(sb, flag);
            append(sb, " ");
        }
        append(sb, "function ");
        append(sb, p.getName());
        append(sb, smallHash(p));
        printTypeVariables(p.getTypeVariables(), sb, indent);
        append(sb, "(");
        boolean first = true;
        for (ImVar p1 : p.getParameters()) {
            if (!first) append(sb, ", ");
            p1.print(sb, indent);
            first = false;
        }
        append(sb, ")");
        if (!(p.getReturnType() instanceof ImVoid)) {
            append(sb, " returns ");
            p.getReturnType().print(sb, indent);
        }
        append(sb, " { \n");
        for (ImVar v : p.getLocals()) {
            indent(sb, indent + 1);
            append(sb, "local ");
            v.print(sb, indent + 1);
            append(sb, "\n");
        }
        p.getBody().print(sb, indent + 1);
        indent(sb, indent);
        append(sb, "}\n\n");
    }

    private static void printTypeVariables(ImTypeVars tvs, Appendable sb, int indent) {
        if (tvs.isEmpty()) {
            return;
        }
        append(sb, "<");
        for (int i = 0; i < tvs.size(); i++) {
            if (i > 0) {
                append(sb, ", ");
            }
            tvs.get(i).print(sb, indent);
        }
        append(sb, ">");
    }

    public static void print(ImIf p, Appendable sb, int indent) {
        append(sb, "if ");
        p.getCondition().print(sb, indent);
        append(sb, "{\n");
        p.getThenBlock().print(sb, indent + 1);
        indent(sb, indent);
        append(sb, "} else {\n");
        p.getElseBlock().print(sb, indent + 1);
        indent(sb, indent);
        append(sb, "}");

    }

    private static void indent(Appendable sb, int indent) {
        for (int i = 0; i < indent; i++) {
            append(sb, "    ");
        }
    }


    public static void print(ImLoop p, Appendable sb, int indent) {
        append(sb, "loop {\n");
        p.getBody().print(sb, indent + 1);
        indent(sb, indent);
        append(sb, "}");
    }

    public static void print(ImExitwhen p, Appendable sb, int indent) {
        append(sb, "exitwhen ");
        p.getCondition().print(sb, indent);
    }

    public static void print(ImReturn p, Appendable sb, int indent) {
        append(sb, "return ");
        p.getReturnValue().print(sb, indent);
    }

    public static void print(ImSet p, Appendable sb, int indent) {
        p.getLeft().print(sb, indent);
        append(sb, " = ");
        p.getRight().print(sb, indent);
    }

    public static void print(ImNoExpr p, Appendable sb, int indent) {
        append(sb, "%nothing%");
    }

    public static void print(ImStatementExpr p, Appendable sb, int indent) {
        append(sb, "{\n");
        p.getStatements().print(sb, indent + 1);
        indent(sb, indent + 1);
        append(sb, ">>>  ");
        p.getExpr().print(sb, indent + 1);
        append(sb, "}");
    }


    public static void print(ImFunctionCall p, Appendable sb, int indent) {
        append(sb, p.getFunc().getName());
        append(sb, smallHash(p.getFunc()));
        printTypeArguments(p.getTypeArguments(), indent, sb);
        printArgumentList(sb, indent, p.getArguments());
    }


    public static void printArgumentList(Appendable sb, int indent,
                                         List<ImExpr> args) {
        append(sb, "(");
        boolean first = true;
        for (ImExpr a : args) {
            if (!first) {
                append(sb, ", ");
            }
            a.print(sb, indent);
            first = false;
        }
        append(sb, ")");
    }


    public static void print(ImVarAccess p, Appendable sb, int indent) {
        append(sb, p.getVar().getName());
        append(sb, "_");
        append(sb, smallHash(p.getVar()));

    }

    public static String smallHash(Object g) {
        String c = "" + g.hashCode();
        return c.substring(0, Math.min(3, c.length() - 1));
    }

    public static void print(ImVarArrayAccess p, Appendable sb, int indent) {
        append(sb, p.getVar().getName());
        append(sb, "_");
        append(sb, smallHash(p.getVar()));
        for (ImExpr ie : p.getIndexes()) {
            append(sb, "[");
            ie.print(sb, indent + 1);
            append(sb, "]");
        }
    }


    public static void print(ImTupleExpr p, Appendable sb, int indent) {
        append(sb, "<");
        boolean first = true;
        for (ImExpr e : p.getExprs()) {
            if (!first) append(sb, ", ");
            e.print(sb, indent);
            first = false;
        }
        append(sb, ">");
    }


    public static void print(ImTupleSelection p, Appendable sb, int indent) {
        p.getTupleExpr().print(sb, indent);
        append(sb, "#");
        append(sb, p.getTupleIndex());
    }


    public static void print(ImIntVal p, Appendable sb, int indent) {
        append(sb, p.getValI());
    }


    public static void print(ImRealVal p, Appendable sb, int indent) {
        append(sb, p.getValR());
    }


    public static void print(ImStringVal p, Appendable sb, int indent) {
        append(sb, '"');
        append(sb, p.getValS());
        append(sb, '"');
    }


    public static void print(ImBoolVal p, Appendable sb, int indent) {
        append(sb, p.getValB() ? "true" : "false");
    }


    public static void print(ImFuncRef p, Appendable sb, int indent) {
        append(sb, "function ");
        append(sb, p.getFunc().getName());
    }


    public static void print(ImNull p, Appendable sb, int indent) {
        append(sb, "null");
        if (!(p.getType() instanceof ImVoid)) {
            append(sb, "<");
            p.getType().print(sb, indent);
            append(sb, ">");
        }
    }


    public static void print(ImStmts ss, Appendable sb, int indent) {
        for (ImStmt s : ss) {
            indent(sb, indent);
            s.print(sb, indent);
            append(sb, ";\n");
        }
    }


    public static void print(ImVar v, Appendable sb, int indent) {
        v.getType().print(sb, indent);
        append(sb, " ");
        append(sb, v.getName());
        append(sb, smallHash(v));
    }


    public static void print(ImOperatorCall e, Appendable sb, int indent) {
        append(sb, "(");
        if (e.getArguments().size() == 2) {
            // binary operator
            e.getArguments().get(0).print(sb, indent);
            append(sb, " ");
            append(sb, e.getOp());
            append(sb, " ");
            e.getArguments().get(1).print(sb, indent);
        } else {
            append(sb, e.getOp());
            for (ImExpr a : e.getArguments()) {
                append(sb, " ");
                a.print(sb, indent);
            }
        }
        append(sb, ")");
    }


    public static String printToString(ImPrintable p) {
        return asString(p);
    }

    public static String asString(ImPrintable p) {
        Appendable sb = new StringBuilder();
        try {
            p.print(sb, 0);
        } catch (Throwable t) {
            t.printStackTrace();
            append(sb, "## error {");
            append(sb, t);
            append(sb, "}");
        }
        return sb.toString();
    }


    public static void print(ImMethodCall mc, Appendable sb,
                             int indent) {
        mc.getReceiver().print(sb, 0);
        append(sb, ".");
        append(sb, mc.getMethod().getName());
        append(sb, smallHash(mc.getMethod()));
        printTypeArguments(mc.getTypeArguments(), indent, sb);
        printArgumentList(sb, 0, mc.getArguments());
    }

    public static String asString(ImFunction f) {
        return f.getName() + smallHash(f);

    }

    public static void print(ImMemberAccess e, Appendable sb,
                             int indent) {
        e.getReceiver().print(sb, 0);
        append(sb, ".");
        append(sb, e.getVar().getName());
        append(sb, smallHash(e.getVar()));
        for (ImExpr index : e.getIndexes()) {
            append(sb, "[");
            index.print(sb, indent);
            append(sb, "]");
        }
        printTypeArguments(e.getTypeArguments(), indent, sb);
    }


    public static void print(ImAlloc e, Appendable sb, int indent) {
        append(sb, "#alloc(");
        e.getClazz().print(sb, indent);
        append(sb, ")");

    }


    public static void print(ImDealloc e, Appendable sb, int indent) {
        append(sb, "#dealloc(");
        e.getClazz().print(sb, indent);
        append(sb, ", ");
        e.getObj().print(sb, 0);
        append(sb, ")");
    }


    public static void print(ImInstanceof e, Appendable sb,
                             int indent) {
        e.getObj().print(sb, 0);
        append(sb, " instanceof ");
        e.getClazz().print(sb, indent);
    }


    public static void print(ImTypeIdOfClass e, Appendable sb,
                             int indent) {
        append(sb, e.getClass().getName());
        append(sb, ".typeId");

    }


    public static void print(ImTypeIdOfObj e, Appendable sb,
                             int indent) {
        e.getObj().print(sb, 0);
        append(sb, ".typeId");
    }


    public static void print(ImArrayTypeMulti imArrayTypeMulti,
                             Appendable sb, int indent) {
        append(sb, "array<");
        imArrayTypeMulti.getEntryType().print(sb, indent);
        append(sb, " size: ");
        append(sb, imArrayTypeMulti.getArraySize());
        append(sb, ">");

    }


    public static void print(ImGetStackTrace e, Appendable sb, int indent) {
        append(sb, "#getStackTrace()");
    }


    public static void print(ImCompiletimeExpr e, Appendable sb, int indent) {
        append(sb, "compiletime<<");
        e.getExpr().print(sb, indent);
        append(sb, ">>");
    }

    public static void print(ImVarargLoop e, Appendable sb, int indent) {
        append(sb, "foreach vararg ");
        e.getLoopVar().print(sb, indent);
        append(sb, " {\n");
        e.getBody().print(sb, indent + 1);
        indent(sb, indent);
        append(sb, "}");
    }


    public static void print(ImTypeVarDispatch e, Appendable sb, int indent) {
        append(sb, "<");
        append(sb, e.getTypeVariable().getName());
        append(sb, ">.");
        append(sb, e.getTypeClassFunc().getName());
        printArgumentList(sb, indent, e.getArguments());
    }

    public static void print(ImTypeVarRef e, Appendable sb, int indent) {
        append(sb, e.getTypeVariable().getName());
        append(sb, smallHash(e.getTypeVariable()));
    }

    public static void print(ImClassType ct, Appendable sb, int indent) {
        append(sb, ct.getClassDef().getName());
        append(sb, smallHash(ct.getClassDef()));
        ImTypeArguments typeArguments = ct.getTypeArguments();
        printTypeArguments(typeArguments, indent, sb);
    }

    private static void printTypeArguments(ImTypeArguments typeArguments, int indent, Appendable sb) {
        if (!typeArguments.isEmpty()) {
            append(sb, "<");
            boolean first = true;
            for (ImTypeArgument ta : typeArguments) {
                if (!first) {
                    append(sb, ", ");
                }
                ta.getType().print(sb, indent);
                first = false;
            }
            append(sb, ">");
        }
    }

    public static void print(ImTypeVar tv, Appendable sb, int indent) {
        append(sb, tv.getName());
        append(sb, smallHash(tv));
    }

    public static String asString(ImStmts s) {
        return asString((ImPrintable) s);
    }

    public static String asString(List<?> s) {
        return "[" + ((List<?>) s).stream()
                    .map(Object::toString)
                    .collect(Collectors.joining(", ")) + "]";
    }

    public static String asString(ImTypeClassFunc s) {
        return s.getName() + smallHash(s);
    }

    public static String asString(ImClass s) {
        return s.getName() + smallHash(s);
    }

    public static String asString(ImMethod s) {
        return s.getName() + smallHash(s);
    }

    public static String asString(ImTypeArgument s) {
        return s.getType() + "" + s.getTypeClassBinding();
    }

    public static void print(ImCast e, Appendable sb, int indent) {
        append(sb, "(");
        e.getExpr().print(sb, indent);
        append(sb, " castTo ");
        e.getToType().print(sb, indent);
        append(sb, ")");
    }
}

1	package de.peeeq.wurstscript.translation.imtranslation;
2
3	import de.peeeq.wurstscript.jassIm.*;
4
5	import java.io.IOException;
6	import java.util.List;
7	import java.util.stream.Collectors;
8
9	public class ImPrinter {	×
10
11
12	public static void print(ImProg p, Appendable sb, int indent) {
13	for (ImVar g : p.getGlobals()) {	1✔
14	g.print(sb, indent);	1✔
15	append(sb, "\n");	1✔
16	}	1✔
17	append(sb, "\n\n");	1✔
18	p.getGlobalInits().forEach((v,es) -> {	1✔
19	append(sb, v.getName());	1✔
20	append(sb, " = ");	1✔
21	boolean first = true;	1✔
22	for (ImExpr e : es) {	1✔
23	if (!first) {	1✔
24	append(sb, ", ");	1✔
25	}
26	e.print(sb, indent);	1✔
27	first = false;	1✔
28	}	1✔
29	append(sb, "\n");	1✔
30	});	1✔
31	append(sb, "\n\n");	1✔
32	for (ImFunction f : p.getFunctions()) {	1✔
33	f.print(sb, indent);	1✔
34	append(sb, "\n");	1✔
35	}	1✔
36	for (ImMethod m : p.getMethods()) {	1✔
37	printMethod(sb, m, indent);	1✔
38	}	1✔
39	append(sb, "\n\n");	1✔
40	for (ImClass c : p.getClasses()) {	1✔
41	print(c, sb, indent);	1✔
42	}	1✔
43
44	}	1✔
45
46	public static void print(ImClass c, Appendable sb, int indent) {
47	append(sb, "class ");	1✔
48	append(sb, c.getName());	1✔
49	append(sb, smallHash(c));	1✔
50	printTypeVariables(c.getTypeVariables(), sb, indent);	1✔
51	append(sb, " extends ");	1✔
52	for (ImClassType sc : c.getSuperClasses()) {	1✔
53	sc.print(sb, indent);	1✔
54	append(sb, " ");	1✔
55	}	1✔
56	append(sb, "{\n");	1✔
57	for (ImVar f : c.getFields()) {	1✔
58	indent(sb, indent + 1);	1✔
59	f.print(sb, indent + 1);	1✔
60	append(sb, "\n");	1✔
61	}	1✔
62	append(sb, "\n\n");	1✔
63	for (ImMethod m : c.getMethods()) {	1✔
64	indent(sb, indent + 1);	1✔
65	printMethod(sb, m, indent + 1);	1✔
66	}	1✔
67
68	for (ImFunction func : c.getFunctions()) {	1✔
69	func.print(sb, indent + 1);	1✔
70	}	1✔
71
72	append(sb, "}\n\n");	1✔
73	}	1✔
74
75	private static void printMethod(Appendable sb, ImMethod m, int indent) {
76	if (m.getIsAbstract()) {	1✔
77	append(sb, "abstract ");	1✔
78	}
79	append(sb, "method ");	1✔
80	m.getMethodClass().print(sb, indent);	1✔
81	append(sb, ".");	1✔
82	append(sb, m.getName());	1✔
83	append(sb, smallHash(m));	1✔
84	append(sb, " implemented by ");	1✔
85	append(sb, m.getImplementation().getName());	1✔
86	append(sb, smallHash(m.getImplementation()));	1✔
87	append(sb, "\n");	1✔
88	for (ImMethod sm : m.getSubMethods()) {	1✔
89	append(sb, " sub: ");	1✔
90	sm.getMethodClass().print(sb, indent);	1✔
91	append(sb, ".");	1✔
92	append(sb, sm.getName());	1✔
93	append(sb, smallHash(sm));	1✔
94	append(sb, "\n");	1✔
95	}	1✔
96	append(sb, "\n");	1✔
97	}	1✔
98
99
100	private static void append(Appendable sb, Object s) {
101	append(sb, s.toString());	1✔
102	}	1✔
103
104	private static void append(Appendable sb, String s) {
105	try {
106	sb.append(s);	1✔
107	} catch (IOException e) {	×
108	throw new RuntimeException(e);	×
109	}	1✔
110	}	1✔
111
112
113	public static void print(ImSimpleType p, Appendable sb, int indent) {
114	append(sb, p.getTypename());	1✔
115	}	1✔
116
117	public static void print(ImArrayType t, Appendable sb, int indent) {
118	append(sb, "array<");	1✔
119	t.getEntryType().print(sb, indent);	1✔
120	append(sb, ">");	1✔
121	}	1✔
122
123	public static void print(ImTupleType p, Appendable sb, int indent) {
124	append(sb, "⦅");	1✔
125	boolean first = true;	1✔
126	for (ImType t : p.getTypes()) {	1✔
127	if (!first) append(sb, ", ");	1✔
128	t.print(sb, indent);	1✔
129	first = false;	1✔
130	}	1✔
131	append(sb, "⦆");	1✔
132	}	1✔
133
134	public static void print(ImVoid p, Appendable sb, int indent) {
135	append(sb, "void");	×
136	}	×
137
138	public static void print(ImFunction p, Appendable sb, int indent) {
139	indent(sb, indent);	1✔
140	for (FunctionFlag flag : p.getFlags()) {	1✔
141	append(sb, flag);	1✔
142	append(sb, " ");	1✔
143	}	1✔
144	append(sb, "function ");	1✔
145	append(sb, p.getName());	1✔
146	append(sb, smallHash(p));	1✔
147	printTypeVariables(p.getTypeVariables(), sb, indent);	1✔
148	append(sb, "(");	1✔
149	boolean first = true;	1✔
150	for (ImVar p1 : p.getParameters()) {	1✔
151	if (!first) append(sb, ", ");	1✔
152	p1.print(sb, indent);	1✔
153	first = false;	1✔
154	}	1✔
155	append(sb, ")");	1✔
156	if (!(p.getReturnType() instanceof ImVoid)) {	1✔
157	append(sb, " returns ");	1✔
158	p.getReturnType().print(sb, indent);	1✔
159	}
160	append(sb, " { \n");	1✔
161	for (ImVar v : p.getLocals()) {	1✔
162	indent(sb, indent + 1);	1✔
163	append(sb, "local ");	1✔
164	v.print(sb, indent + 1);	1✔
165	append(sb, "\n");	1✔
166	}	1✔
167	p.getBody().print(sb, indent + 1);	1✔
168	indent(sb, indent);	1✔
169	append(sb, "}\n\n");	1✔
170	}	1✔
171
172	private static void printTypeVariables(ImTypeVars tvs, Appendable sb, int indent) {
173	if (tvs.isEmpty()) {	1✔
174	return;	1✔
175	}
176	append(sb, "<");	×
177	for (int i = 0; i < tvs.size(); i++) {	×
178	if (i > 0) {	×
179	append(sb, ", ");	×
180	}
181	tvs.get(i).print(sb, indent);	×
182	}
183	append(sb, ">");	×
184	}	×
185
186	public static void print(ImIf p, Appendable sb, int indent) {
187	append(sb, "if ");	1✔
188	p.getCondition().print(sb, indent);	1✔
189	append(sb, "{\n");	1✔
190	p.getThenBlock().print(sb, indent + 1);	1✔
191	indent(sb, indent);	1✔
192	append(sb, "} else {\n");	1✔
193	p.getElseBlock().print(sb, indent + 1);	1✔
194	indent(sb, indent);	1✔
195	append(sb, "}");	1✔
196
197	}	1✔
198
199	private static void indent(Appendable sb, int indent) {
200	for (int i = 0; i < indent; i++) {	1✔
201	append(sb, " ");	1✔
202	}
203	}	1✔
204
205
206	public static void print(ImLoop p, Appendable sb, int indent) {
207	append(sb, "loop {\n");	1✔
208	p.getBody().print(sb, indent + 1);	1✔
209	indent(sb, indent);	1✔
210	append(sb, "}");	1✔
211	}	1✔
212
213	public static void print(ImExitwhen p, Appendable sb, int indent) {
214	append(sb, "exitwhen ");	1✔
215	p.getCondition().print(sb, indent);	1✔
216	}	1✔
217
218	public static void print(ImReturn p, Appendable sb, int indent) {
219	append(sb, "return ");	1✔
220	p.getReturnValue().print(sb, indent);	1✔
221	}	1✔
222
223	public static void print(ImSet p, Appendable sb, int indent) {
224	p.getLeft().print(sb, indent);	1✔
225	append(sb, " = ");	1✔
226	p.getRight().print(sb, indent);	1✔
227	}	1✔
228
229	public static void print(ImNoExpr p, Appendable sb, int indent) {
230	append(sb, "%nothing%");	1✔
231	}	1✔
232
233	public static void print(ImStatementExpr p, Appendable sb, int indent) {
234	append(sb, "{\n");	1✔
235	p.getStatements().print(sb, indent + 1);	1✔
236	indent(sb, indent + 1);	1✔
237	append(sb, ">>> ");	1✔
238	p.getExpr().print(sb, indent + 1);	1✔
239	append(sb, "}");	1✔
240	}	1✔
241
242
243	public static void print(ImFunctionCall p, Appendable sb, int indent) {
244	append(sb, p.getFunc().getName());	1✔
245	append(sb, smallHash(p.getFunc()));	1✔
246	printTypeArguments(p.getTypeArguments(), indent, sb);	1✔
247	printArgumentList(sb, indent, p.getArguments());	1✔
248	}	1✔
249
250
251	public static void printArgumentList(Appendable sb, int indent,
252	List<ImExpr> args) {
253	append(sb, "(");	1✔
254	boolean first = true;	1✔
255	for (ImExpr a : args) {	1✔
256	if (!first) {	1✔
257	append(sb, ", ");	1✔
258	}
259	a.print(sb, indent);	1✔
260	first = false;	1✔
261	}	1✔
262	append(sb, ")");	1✔
263	}	1✔
264
265
266	public static void print(ImVarAccess p, Appendable sb, int indent) {
267	append(sb, p.getVar().getName());	1✔
268	append(sb, "_");	1✔
269	append(sb, smallHash(p.getVar()));	1✔
270
271	}	1✔
272
273	public static String smallHash(Object g) {
274	String c = "" + g.hashCode();	1✔
275	return c.substring(0, Math.min(3, c.length() - 1));	1✔
276	}
277
278	public static void print(ImVarArrayAccess p, Appendable sb, int indent) {
279	append(sb, p.getVar().getName());	1✔
280	append(sb, "_");	1✔
281	append(sb, smallHash(p.getVar()));	1✔
282	for (ImExpr ie : p.getIndexes()) {	1✔
283	append(sb, "[");	1✔
284	ie.print(sb, indent + 1);	1✔
285	append(sb, "]");	1✔
286	}	1✔
287	}	1✔
288
289
290	public static void print(ImTupleExpr p, Appendable sb, int indent) {
291	append(sb, "<");	1✔
292	boolean first = true;	1✔
293	for (ImExpr e : p.getExprs()) {	1✔
294	if (!first) append(sb, ", ");	1✔
295	e.print(sb, indent);	1✔
296	first = false;	1✔
297	}	1✔
298	append(sb, ">");	1✔
299	}	1✔
300
301
302	public static void print(ImTupleSelection p, Appendable sb, int indent) {
303	p.getTupleExpr().print(sb, indent);	1✔
304	append(sb, "#");	1✔
305	append(sb, p.getTupleIndex());	1✔
306	}	1✔
307
308
309	public static void print(ImIntVal p, Appendable sb, int indent) {
310	append(sb, p.getValI());	1✔
311	}	1✔
312
313
314	public static void print(ImRealVal p, Appendable sb, int indent) {
315	append(sb, p.getValR());	1✔
316	}	1✔
317
318
319	public static void print(ImStringVal p, Appendable sb, int indent) {
320	append(sb, '"');	1✔
321	append(sb, p.getValS());	1✔
322	append(sb, '"');	1✔
323	}	1✔
324
325
326	public static void print(ImBoolVal p, Appendable sb, int indent) {
327	append(sb, p.getValB() ? "true" : "false");	1✔
328	}	1✔
329
330
331	public static void print(ImFuncRef p, Appendable sb, int indent) {
332	append(sb, "function ");	1✔
333	append(sb, p.getFunc().getName());	1✔
334	}	1✔
335
336
337	public static void print(ImNull p, Appendable sb, int indent) {
338	append(sb, "null");	1✔
339	if (!(p.getType() instanceof ImVoid)) {	1✔
340	append(sb, "<");	1✔
341	p.getType().print(sb, indent);	1✔
342	append(sb, ">");	1✔
343	}
344	}	1✔
345
346
347	public static void print(ImStmts ss, Appendable sb, int indent) {
348	for (ImStmt s : ss) {	1✔
349	indent(sb, indent);	1✔
350	s.print(sb, indent);	1✔
351	append(sb, ";\n");	1✔
352	}	1✔
353	}	1✔
354
355
356	public static void print(ImVar v, Appendable sb, int indent) {
357	v.getType().print(sb, indent);	1✔
358	append(sb, " ");	1✔
359	append(sb, v.getName());	1✔
360	append(sb, smallHash(v));	1✔
361	}	1✔
362
363
364	public static void print(ImOperatorCall e, Appendable sb, int indent) {
365	append(sb, "(");	1✔
366	if (e.getArguments().size() == 2) {	1✔
367	// binary operator
368	e.getArguments().get(0).print(sb, indent);	1✔
369	append(sb, " ");	1✔
370	append(sb, e.getOp());	1✔
371	append(sb, " ");	1✔
372	e.getArguments().get(1).print(sb, indent);	1✔
373	} else {
374	append(sb, e.getOp());	1✔
375	for (ImExpr a : e.getArguments()) {	1✔
376	append(sb, " ");	1✔
377	a.print(sb, indent);	1✔
378	}	1✔
379	}
380	append(sb, ")");	1✔
381	}	1✔
382
383
384	public static String printToString(ImPrintable p) {
385	return asString(p);	×
386	}
387
388	public static String asString(ImPrintable p) {
389	Appendable sb = new StringBuilder();	1✔
390	try {
391	p.print(sb, 0);	1✔
392	} catch (Throwable t) {	×
393	t.printStackTrace();	×
394	append(sb, "## error {");	×
395	append(sb, t);	×
396	append(sb, "}");	×
397	}	1✔
398	return sb.toString();	1✔
399	}
400
401
402	public static void print(ImMethodCall mc, Appendable sb,
403	int indent) {
404	mc.getReceiver().print(sb, 0);	1✔
405	append(sb, ".");	1✔
406	append(sb, mc.getMethod().getName());	1✔
407	append(sb, smallHash(mc.getMethod()));	1✔
408	printTypeArguments(mc.getTypeArguments(), indent, sb);	1✔
409	printArgumentList(sb, 0, mc.getArguments());	1✔
410	}	1✔
411
412	public static String asString(ImFunction f) {
413	return f.getName() + smallHash(f);	1✔
414
415	}
416
417	public static void print(ImMemberAccess e, Appendable sb,
418	int indent) {
419	e.getReceiver().print(sb, 0);	1✔
420	append(sb, ".");	1✔
421	append(sb, e.getVar().getName());	1✔
422	append(sb, smallHash(e.getVar()));	1✔
423	for (ImExpr index : e.getIndexes()) {	1✔
424	append(sb, "[");	1✔
425	index.print(sb, indent);	1✔
426	append(sb, "]");	1✔
427	}	1✔
428	printTypeArguments(e.getTypeArguments(), indent, sb);	1✔
429	}	1✔
430
431
432	public static void print(ImAlloc e, Appendable sb, int indent) {
433	append(sb, "#alloc(");	1✔
434	e.getClazz().print(sb, indent);	1✔
435	append(sb, ")");	1✔
436
437	}	1✔
438
439
440	public static void print(ImDealloc e, Appendable sb, int indent) {
441	append(sb, "#dealloc(");	1✔
442	e.getClazz().print(sb, indent);	1✔
443	append(sb, ", ");	1✔
444	e.getObj().print(sb, 0);	1✔
445	append(sb, ")");	1✔
446	}	1✔
447
448
449	public static void print(ImInstanceof e, Appendable sb,
450	int indent) {
451	e.getObj().print(sb, 0);	1✔
452	append(sb, " instanceof ");	1✔
453	e.getClazz().print(sb, indent);	1✔
454	}	1✔
455
456
457	public static void print(ImTypeIdOfClass e, Appendable sb,
458	int indent) {
459	append(sb, e.getClass().getName());	1✔
460	append(sb, ".typeId");	1✔
461
462	}	1✔
463
464
465	public static void print(ImTypeIdOfObj e, Appendable sb,
466	int indent) {
467	e.getObj().print(sb, 0);	1✔
468	append(sb, ".typeId");	1✔
469	}	1✔
470
471
472	public static void print(ImArrayTypeMulti imArrayTypeMulti,
473	Appendable sb, int indent) {
474	append(sb, "array<");	1✔
475	imArrayTypeMulti.getEntryType().print(sb, indent);	1✔
476	append(sb, " size: ");	1✔
477	append(sb, imArrayTypeMulti.getArraySize());	1✔
478	append(sb, ">");	1✔
479
480	}	1✔
481
482
483	public static void print(ImGetStackTrace e, Appendable sb, int indent) {
484	append(sb, "#getStackTrace()");	1✔
485	}	1✔
486
487
488	public static void print(ImCompiletimeExpr e, Appendable sb, int indent) {
489	append(sb, "compiletime<<");	1✔
490	e.getExpr().print(sb, indent);	1✔
491	append(sb, ">>");	1✔
492	}	1✔
493
494	public static void print(ImVarargLoop e, Appendable sb, int indent) {
495	append(sb, "foreach vararg ");	1✔
496	e.getLoopVar().print(sb, indent);	1✔
497	append(sb, " {\n");	1✔
498	e.getBody().print(sb, indent + 1);	1✔
499	indent(sb, indent);	1✔
500	append(sb, "}");	1✔
501	}	1✔
502
503
504	public static void print(ImTypeVarDispatch e, Appendable sb, int indent) {
505	append(sb, "<");	×
506	append(sb, e.getTypeVariable().getName());	×
507	append(sb, ">.");	×
508	append(sb, e.getTypeClassFunc().getName());	×
509	printArgumentList(sb, indent, e.getArguments());	×
510	}	×
511
512	public static void print(ImTypeVarRef e, Appendable sb, int indent) {
513	append(sb, e.getTypeVariable().getName());	×
514	append(sb, smallHash(e.getTypeVariable()));	×
515	}	×
516
517	public static void print(ImClassType ct, Appendable sb, int indent) {
518	append(sb, ct.getClassDef().getName());	1✔
519	append(sb, smallHash(ct.getClassDef()));	1✔
520	ImTypeArguments typeArguments = ct.getTypeArguments();	1✔
521	printTypeArguments(typeArguments, indent, sb);	1✔
522	}	1✔
523
524	private static void printTypeArguments(ImTypeArguments typeArguments, int indent, Appendable sb) {
525	if (!typeArguments.isEmpty()) {	1✔
526	append(sb, "<");	×
527	boolean first = true;	×
528	for (ImTypeArgument ta : typeArguments) {	×
529	if (!first) {	×
530	append(sb, ", ");	×
531	}
532	ta.getType().print(sb, indent);	×
533	first = false;	×
534	}	×
535	append(sb, ">");	×
536	}
537	}	1✔
538
539	public static void print(ImTypeVar tv, Appendable sb, int indent) {
540	append(sb, tv.getName());	×
541	append(sb, smallHash(tv));	×
542	}	×
543
544	public static String asString(ImStmts s) {
545	return asString((ImPrintable) s);	×
546	}
547
548	public static String asString(List<?> s) {
549	return "[" + ((List<?>) s).stream()	×
550	.map(Object::toString)	×
551	.collect(Collectors.joining(", ")) + "]";	×
552	}
553
554	public static String asString(ImTypeClassFunc s) {
555	return s.getName() + smallHash(s);	×
556	}
557
558	public static String asString(ImClass s) {
559	return s.getName() + smallHash(s);	×
560	}
561
562	public static String asString(ImMethod s) {
563	return s.getName() + smallHash(s);	×
564	}
565
566	public static String asString(ImTypeArgument s) {
567	return s.getType() + "" + s.getTypeClassBinding();	×
568	}
569
570	public static void print(ImCast e, Appendable sb, int indent) {
571	append(sb, "(");	1✔
572	e.getExpr().print(sb, indent);	1✔
573	append(sb, " castTo ");	1✔
574	e.getToType().print(sb, indent);	1✔
575	append(sb, ")");	1✔
576	}	1✔
577	}

wurstscript / WurstScript / 1005

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