wurstscript / WurstScript / 228

Committed 29 Nov 2023 05:00PM UTC coverage: 62.48% (-0.09%) from 62.574%

Build # 228

Build Type

push

circleci

Committed by

web-flow

Commit Message

Show dialog for choosing game path, cleanup (#1083)

* show dialog for choosing game path

* cleanup code

* remove logs and refactor

* remove confusing mpq error, make some mpq loads readonly

Run Details

17295 of 27681 relevant lines covered (62.48%)

0.62 hits per line

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

83.72

de.peeeq.wurstscript/src/main/java/de/peeeq/wurstscript/translation/lua/translation/RemoveGarbage.java

package de.peeeq.wurstscript.translation.lua.translation;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import de.peeeq.wurstscript.jassIm.*;
import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
import de.peeeq.wurstscript.validation.TRVEHelper;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * Removes every class, function, method and global variable
 * that is not used from main or config
 */
public class RemoveGarbage {

    private static class Used {
        private final Set<ImFunction> functions = new HashSet<>();
        private final Set<ImMethod> methods = new HashSet<>();
        // methods that will be added once the class is used:
        private final Multimap<ImClass, ImMethod> waitingMethods = HashMultimap.create();
        private final Set<ImClass> classes = new HashSet<>();
        private final Set<ImVar> vars = new HashSet<>();

        public void addMethod(ImMethod m) {
            methods.add(m);
        }

        public void maybeVisitMethod(ImMethod m) {
            ImClass c = m.attrClass();
            if (classes.contains(c)) {
                visitMethod(m, this);
            } else {
                waitingMethods.put(c, m);
            }
        }

        public Set<ImFunction> getFunctions() {
            return functions;
        }

        public Set<ImMethod> getMethods() {
            return methods;
        }

        public Set<ImClass> getClasses() {
            return classes;
        }

        public Set<ImVar> getVars() {
            return vars;
        }

        public void addFunction(ImFunction f) {
            functions.add(f);
        }

        public void addVar(ImVar var) {
            vars.add(var);
        }

        public void addClass(ImClass c) {
            classes.add(c);
            Collection<ImMethod> imMethods = waitingMethods.get(c);
            Iterator<ImMethod> it = imMethods.iterator();
            while (it.hasNext()) {
                ImMethod m = it.next();
                visitMethod(m, this);
                it.remove();
            }
        }
    }

    public static void removeGarbage(ImProg prog) {
        Used used = new Used();
        for (ImFunction f : ImHelper.calculateFunctionsOfProg(prog)) {
            if (f.getName().equals("main")
                || f.getName().equals("config")) {
                visitFunction(f, used);
            }
        }

        prog.getClasses().removeIf(c -> !used.getClasses().contains(c));
        prog.getGlobals().removeIf(g -> !used.getVars().contains(g) && !TRVEHelper.protectedVariables.contains(g.getName()));
        prog.getFunctions().removeIf(f -> !used.getFunctions().contains(f));
        for (ImClass c : prog.getClasses()) {
            c.getFields().removeIf(g -> !used.getVars().contains(g));
            c.getFunctions().removeIf(f -> !used.getFunctions().contains(f));
            c.getMethods().removeIf(m -> !used.getMethods().contains(m));
            for (ImMethod m : c.getMethods()) {
                m.getSubMethods().removeIf(sm -> !used.getMethods().contains(sm));
            }
        }

    }

    private static void visitFunction(ImFunction f, Used used) {
        if (used.getFunctions().contains(f)) {
            return;
        }
        used.addFunction(f);

        visitType(f.getReturnType(), used);
        f.accept(new Element.DefaultVisitor() {
            @Override
            public void visit(ImFunctionCall e) {
                super.visit(e);
                visitFunction(e.getFunc(), used);
            }

            @Override
            public void visit(ImVar e) {
                super.visit(e);
                visitType(e.getType(), used);
            }

            @Override
            public void visit(ImFuncRef e) {
                super.visit(e);
                visitFunction(e.getFunc(), used);
            }

            @Override
            public void visit(ImCast e) {
                super.visit(e);
                visitType(e.getToType(), used);
            }

            @Override
            public void visit(ImVarAccess e) {
                super.visit(e);
                used.addVar(e.getVar());
            }

            @Override
            public void visit(ImVarArrayAccess e) {
                super.visit(e);
                used.addVar(e.getVar());
            }

            @Override
            public void visit(ImAlloc e) {
                super.visit(e);
                visitClass(e.getClazz().getClassDef(), used);
            }

            @Override
            public void visit(ImDealloc e) {
                super.visit(e);
                visitClass(e.getClazz().getClassDef(), used);
            }

            @Override
            public void visit(ImInstanceof e) {
                super.visit(e);
                visitClass(e.getClazz().getClassDef(), used);
            }

            @Override
            public void visit(ImTypeIdOfObj e) {
                super.visit(e);
                visitClass(e.getClazz().getClassDef(), used);
            }

            @Override
            public void visit(ImTypeIdOfClass e) {
                super.visit(e);
                visitClass(e.getClazz().getClassDef(), used);
            }

            @Override
            public void visit(ImMethodCall e) {
                super.visit(e);
                visitMethod(e.getMethod(), used);
            }

            @Override
            public void visit(ImMemberAccess e) {
                super.visit(e);
                used.addVar(e.getVar());
            }
        });
    }

    private static void visitMethod(ImMethod m, Used used) {
        if (used.getMethods().contains(m)) {
            return;
        }
        used.addMethod(m);
        visitClass(m.getMethodClass().getClassDef(), used);
        visitFunction(m.getImplementation(), used);
        for (ImMethod subMethod : m.getSubMethods()) {
            used.maybeVisitMethod(subMethod);
        }
    }

    private static void visitClass(ImClass c, Used used) {
        if (used.getClasses().contains(c)) {
            return;
        }
        used.addClass(c);
        for (ImClassType superClass : c.getSuperClasses()) {
            visitClass(superClass.getClassDef(), used);
        }
    }

    private static void visitType(ImType t, Used used) {
        t.match(new ImType.MatcherVoid() {

            @Override
            public void case_ImAnyType(ImAnyType imAnyType) {

            }

            @Override
            public void case_ImTupleType(ImTupleType tt) {
                for (ImType type : tt.getTypes()) {
                    visitType(type, used);
                }
            }

            @Override
            public void case_ImTypeVarRef(ImTypeVarRef tt) {

            }

            @Override
            public void case_ImVoid(ImVoid tt) {

            }

            @Override
            public void case_ImSimpleType(ImSimpleType tt) {

            }

            @Override
            public void case_ImArrayTypeMulti(ImArrayTypeMulti tt) {
                visitType(tt.getEntryType(), used);
            }

            @Override
            public void case_ImClassType(ImClassType tt) {
                visitClass(tt.getClassDef(), used);
                for (ImTypeArgument ta : tt.getTypeArguments()) {
                    visitType(ta.getType(), used);
                }
            }

            @Override
            public void case_ImArrayType(ImArrayType tt) {
                visitType(tt.getEntryType(), used);
            }
        });

    }
}

1	package de.peeeq.wurstscript.translation.lua.translation;
2
3	import com.google.common.collect.HashMultimap;
4	import com.google.common.collect.Multimap;
5	import de.peeeq.wurstscript.jassIm.*;
6	import de.peeeq.wurstscript.translation.imtranslation.ImHelper;
7	import de.peeeq.wurstscript.validation.TRVEHelper;
8
9	import java.util.Collection;
10	import java.util.HashSet;
11	import java.util.Iterator;
12	import java.util.Set;
13
14	/**
15	* Removes every class, function, method and global variable
16	* that is not used from main or config
17	*/
18	public class RemoveGarbage {	×
19
20	private static class Used {	1✔
21	private final Set<ImFunction> functions = new HashSet<>();	1✔
22	private final Set<ImMethod> methods = new HashSet<>();	1✔
23	// methods that will be added once the class is used:
24	private final Multimap<ImClass, ImMethod> waitingMethods = HashMultimap.create();	1✔
25	private final Set<ImClass> classes = new HashSet<>();	1✔
26	private final Set<ImVar> vars = new HashSet<>();	1✔
27
28	public void addMethod(ImMethod m) {
29	methods.add(m);	1✔
30	}	1✔
31
32	public void maybeVisitMethod(ImMethod m) {
33	ImClass c = m.attrClass();	1✔
34	if (classes.contains(c)) {	1✔
35	visitMethod(m, this);	1✔
36	} else {
37	waitingMethods.put(c, m);	1✔
38	}
39	}	1✔
40
41	public Set<ImFunction> getFunctions() {
42	return functions;	1✔
43	}
44
45	public Set<ImMethod> getMethods() {
46	return methods;	1✔
47	}
48
49	public Set<ImClass> getClasses() {
50	return classes;	1✔
51	}
52
53	public Set<ImVar> getVars() {
54	return vars;	1✔
55	}
56
57	public void addFunction(ImFunction f) {
58	functions.add(f);	1✔
59	}	1✔
60
61	public void addVar(ImVar var) {
62	vars.add(var);	1✔
63	}	1✔
64
65	public void addClass(ImClass c) {
66	classes.add(c);	1✔
67	Collection<ImMethod> imMethods = waitingMethods.get(c);	1✔
68	Iterator<ImMethod> it = imMethods.iterator();	1✔
69	while (it.hasNext()) {	1✔
70	ImMethod m = it.next();	×
71	visitMethod(m, this);	×
72	it.remove();	×
73	}	×
74	}	1✔
75	}
76
77	public static void removeGarbage(ImProg prog) {
78	Used used = new Used();	1✔
79	for (ImFunction f : ImHelper.calculateFunctionsOfProg(prog)) {	1✔
80	if (f.getName().equals("main")	1✔
81	\|\| f.getName().equals("config")) {	1✔
82	visitFunction(f, used);	1✔
83	}
84	}	1✔
85
86	prog.getClasses().removeIf(c -> !used.getClasses().contains(c));	1✔
87	prog.getGlobals().removeIf(g -> !used.getVars().contains(g) && !TRVEHelper.protectedVariables.contains(g.getName()));	1✔
88	prog.getFunctions().removeIf(f -> !used.getFunctions().contains(f));	1✔
89	for (ImClass c : prog.getClasses()) {	1✔
90	c.getFields().removeIf(g -> !used.getVars().contains(g));	1✔
91	c.getFunctions().removeIf(f -> !used.getFunctions().contains(f));	1✔
92	c.getMethods().removeIf(m -> !used.getMethods().contains(m));	1✔
93	for (ImMethod m : c.getMethods()) {	1✔
94	m.getSubMethods().removeIf(sm -> !used.getMethods().contains(sm));	1✔
95	}	1✔
96	}	1✔
97
98	}	1✔
99
100	private static void visitFunction(ImFunction f, Used used) {
101	if (used.getFunctions().contains(f)) {	1✔
102	return;	1✔
103	}
104	used.addFunction(f);	1✔
105
106	visitType(f.getReturnType(), used);	1✔
107	f.accept(new Element.DefaultVisitor() {	1✔
108	@Override
109	public void visit(ImFunctionCall e) {
110	super.visit(e);	1✔
111	visitFunction(e.getFunc(), used);	1✔
112	}	1✔
113
114	@Override
115	public void visit(ImVar e) {
116	super.visit(e);	1✔
117	visitType(e.getType(), used);	1✔
118	}	1✔
119
120	@Override
121	public void visit(ImFuncRef e) {
122	super.visit(e);	1✔
123	visitFunction(e.getFunc(), used);	1✔
124	}	1✔
125
126	@Override
127	public void visit(ImCast e) {
128	super.visit(e);	1✔
129	visitType(e.getToType(), used);	1✔
130	}	1✔
131
132	@Override
133	public void visit(ImVarAccess e) {
134	super.visit(e);	1✔
135	used.addVar(e.getVar());	1✔
136	}	1✔
137
138	@Override
139	public void visit(ImVarArrayAccess e) {
140	super.visit(e);	1✔
141	used.addVar(e.getVar());	1✔
142	}	1✔
143
144	@Override
145	public void visit(ImAlloc e) {
146	super.visit(e);	1✔
147	visitClass(e.getClazz().getClassDef(), used);	1✔
148	}	1✔
149
150	@Override
151	public void visit(ImDealloc e) {
152	super.visit(e);	1✔
153	visitClass(e.getClazz().getClassDef(), used);	1✔
154	}	1✔
155
156	@Override
157	public void visit(ImInstanceof e) {
158	super.visit(e);	×
159	visitClass(e.getClazz().getClassDef(), used);	×
160	}	×
161
162	@Override
163	public void visit(ImTypeIdOfObj e) {
164	super.visit(e);	×
165	visitClass(e.getClazz().getClassDef(), used);	×
166	}	×
167
168	@Override
169	public void visit(ImTypeIdOfClass e) {
170	super.visit(e);	×
171	visitClass(e.getClazz().getClassDef(), used);	×
172	}	×
173
174	@Override
175	public void visit(ImMethodCall e) {
176	super.visit(e);	1✔
177	visitMethod(e.getMethod(), used);	1✔
178	}	1✔
179
180	@Override
181	public void visit(ImMemberAccess e) {
182	super.visit(e);	1✔
183	used.addVar(e.getVar());	1✔
184	}	1✔
185	});
186	}	1✔
187
188	private static void visitMethod(ImMethod m, Used used) {
189	if (used.getMethods().contains(m)) {	1✔
190	return;	1✔
191	}
192	used.addMethod(m);	1✔
193	visitClass(m.getMethodClass().getClassDef(), used);	1✔
194	visitFunction(m.getImplementation(), used);	1✔
195	for (ImMethod subMethod : m.getSubMethods()) {	1✔
196	used.maybeVisitMethod(subMethod);	1✔
197	}	1✔
198	}	1✔
199
200	private static void visitClass(ImClass c, Used used) {
201	if (used.getClasses().contains(c)) {	1✔
202	return;	1✔
203	}
204	used.addClass(c);	1✔
205	for (ImClassType superClass : c.getSuperClasses()) {	1✔
206	visitClass(superClass.getClassDef(), used);	1✔
207	}	1✔
208	}	1✔
209
210	private static void visitType(ImType t, Used used) {
211	t.match(new ImType.MatcherVoid() {	1✔
212
213	@Override
214	public void case_ImAnyType(ImAnyType imAnyType) {
215
216	}	1✔
217
218	@Override
219	public void case_ImTupleType(ImTupleType tt) {
220	for (ImType type : tt.getTypes()) {	1✔
221	visitType(type, used);	1✔
222	}	1✔
223	}	1✔
224
225	@Override
226	public void case_ImTypeVarRef(ImTypeVarRef tt) {
227
228	}	×
229
230	@Override
231	public void case_ImVoid(ImVoid tt) {
232
233	}	1✔
234
235	@Override
236	public void case_ImSimpleType(ImSimpleType tt) {
237
238	}	1✔
239
240	@Override
241	public void case_ImArrayTypeMulti(ImArrayTypeMulti tt) {
242	visitType(tt.getEntryType(), used);	×
243	}	×
244
245	@Override
246	public void case_ImClassType(ImClassType tt) {
247	visitClass(tt.getClassDef(), used);	1✔
248	for (ImTypeArgument ta : tt.getTypeArguments()) {	1✔
249	visitType(ta.getType(), used);	×
250	}	×
251	}	1✔
252
253	@Override
254	public void case_ImArrayType(ImArrayType tt) {
255	visitType(tt.getEntryType(), used);	×
256	}	×
257	});
258
259	}	1✔
260	}

wurstscript / WurstScript / 228

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