summaryrefslogtreecommitdiff
path: root/src/main/java/cuchaz/enigma/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/cuchaz/enigma/analysis')
-rw-r--r--src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java135
-rw-r--r--src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java8
-rw-r--r--src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java20
-rw-r--r--src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java356
-rw-r--r--src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java354
5 files changed, 160 insertions, 713 deletions
diff --git a/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java b/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java
new file mode 100644
index 0000000..17ae63d
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/analysis/AddJavadocsAstTransform.java
@@ -0,0 +1,135 @@
1package cuchaz.enigma.analysis;
2
3import com.google.common.base.Function;
4import com.google.common.base.Strings;
5import com.strobel.assembler.metadata.ParameterDefinition;
6import com.strobel.decompiler.languages.java.ast.*;
7import com.strobel.decompiler.languages.java.ast.transforms.IAstTransform;
8import cuchaz.enigma.translation.mapping.EntryMapping;
9import cuchaz.enigma.translation.mapping.EntryRemapper;
10import cuchaz.enigma.translation.mapping.EntryResolver;
11import cuchaz.enigma.translation.mapping.ResolutionStrategy;
12import cuchaz.enigma.translation.representation.TypeDescriptor;
13import cuchaz.enigma.translation.representation.entry.*;
14
15import java.util.ArrayList;
16import java.util.Collections;
17import java.util.List;
18import java.util.Objects;
19import java.util.stream.Stream;
20
21public final class AddJavadocsAstTransform implements IAstTransform {
22
23 private final EntryRemapper remapper;
24
25 public AddJavadocsAstTransform(EntryRemapper remapper) {
26 this.remapper = remapper;
27 }
28
29 @Override
30 public void run(AstNode compilationUnit) {
31 compilationUnit.acceptVisitor(new Visitor(remapper), null);
32 }
33
34 static class Visitor extends DepthFirstAstVisitor<Void, Void> {
35
36 private final EntryRemapper remapper;
37
38 Visitor(EntryRemapper remapper) {
39 this.remapper = remapper;
40 }
41
42 private <T extends AstNode> void addDoc(T node, Function<T, Entry<?>> retriever) {
43 final Comment[] comments = getComments(node, retriever);
44 if (comments != null) {
45 node.insertChildrenBefore(node.getFirstChild(), Roles.COMMENT, comments);
46 }
47 }
48
49 private <T extends AstNode> Comment[] getComments(T node, Function<T, Entry<?>> retriever) {
50 final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
51 final String docs = mapping == null ? null : Strings.emptyToNull(mapping.getJavadoc());
52 return docs == null ? null : Stream.of(docs.split("\\R")).map(st -> new Comment(st,
53 CommentType.Documentation)).toArray(Comment[]::new);
54 }
55
56 private Comment[] getParameterComments(ParameterDeclaration node, Function<ParameterDeclaration, Entry<?>> retriever) {
57 final EntryMapping mapping = remapper.getDeobfMapping(retriever.apply(node));
58 final Comment[] ret = getComments(node, retriever);
59 if (ret != null) {
60 final String paramPrefix = "@param " + mapping.getTargetName() + " ";
61 final String indent = Strings.repeat(" ", paramPrefix.length());
62 ret[0].setContent(paramPrefix + ret[0].getContent());
63 for (int i = 1; i < ret.length; i++) {
64 ret[i].setContent(indent + ret[i].getContent());
65 }
66 }
67 return ret;
68 }
69
70 private void visitMethod(AstNode node) {
71 final MethodDefEntry methodDefEntry = MethodDefEntry.parse(node.getUserData(Keys.METHOD_DEFINITION));
72 final Comment[] baseComments = getComments(node, $ -> methodDefEntry);
73 List<Comment> comments = new ArrayList<>();
74 if (baseComments != null)
75 Collections.addAll(comments, baseComments);
76
77 for (ParameterDeclaration dec : node.getChildrenByRole(Roles.PARAMETER)) {
78 ParameterDefinition def = dec.getUserData(Keys.PARAMETER_DEFINITION);
79 final Comment[] paramComments = getParameterComments(dec, $ -> new LocalVariableDefEntry(methodDefEntry, def.getSlot(), def.getName(),
80 true,
81 TypeDescriptor.parse(def.getParameterType()), null));
82 if (paramComments != null)
83 Collections.addAll(comments, paramComments);
84 }
85
86 if (!comments.isEmpty()) {
87 if (remapper.getObfResolver().resolveEntry(methodDefEntry, ResolutionStrategy.RESOLVE_ROOT).stream().noneMatch(e -> Objects.equals(e, methodDefEntry))) {
88 comments.add(0, new Comment("{@inheritDoc}", CommentType.Documentation));
89 }
90 final AstNode oldFirst = node.getFirstChild();
91 for (Comment comment : comments) {
92 node.insertChildBefore(oldFirst, comment, Roles.COMMENT);
93 }
94 }
95 }
96
97 @Override
98 protected Void visitChildren(AstNode node, Void data) {
99 for (final AstNode child : node.getChildren()) {
100 child.acceptVisitor(this, data);
101 }
102 return null;
103 }
104
105 @Override
106 public Void visitMethodDeclaration(MethodDeclaration node, Void data) {
107 visitMethod(node);
108 return super.visitMethodDeclaration(node, data);
109 }
110
111 @Override
112 public Void visitConstructorDeclaration(ConstructorDeclaration node, Void data) {
113 visitMethod(node);
114 return super.visitConstructorDeclaration(node, data);
115 }
116
117 @Override
118 public Void visitFieldDeclaration(FieldDeclaration node, Void data) {
119 addDoc(node, dec -> FieldDefEntry.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
120 return super.visitFieldDeclaration(node, data);
121 }
122
123 @Override
124 public Void visitTypeDeclaration(TypeDeclaration node, Void data) {
125 addDoc(node, dec -> ClassDefEntry.parse(dec.getUserData(Keys.TYPE_DEFINITION)));
126 return super.visitTypeDeclaration(node, data);
127 }
128
129 @Override
130 public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void data) {
131 addDoc(node, dec -> FieldDefEntry.parse(dec.getUserData(Keys.FIELD_DEFINITION)));
132 return super.visitEnumValueDeclaration(node, data);
133 }
134 }
135}
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
index c977703..2a72cb1 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexClassVisitor.java
@@ -40,7 +40,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
40 return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index); 40 return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
41 } 41 }
42 42
43 return recurse(node, index); 43 return visitChildren(node, index);
44 } 44 }
45 45
46 @Override 46 @Override
@@ -51,7 +51,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
51 index.addReference(node.getIdentifierToken(), classEntry, this.classEntry); 51 index.addReference(node.getIdentifierToken(), classEntry, this.classEntry);
52 } 52 }
53 53
54 return recurse(node, index); 54 return visitChildren(node, index);
55 } 55 }
56 56
57 @Override 57 @Override
@@ -82,7 +82,7 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
82 assert (node.getVariables().size() == 1); 82 assert (node.getVariables().size() == 1);
83 VariableInitializer variable = node.getVariables().firstOrNullObject(); 83 VariableInitializer variable = node.getVariables().firstOrNullObject();
84 index.addDeclaration(variable.getNameToken(), fieldEntry); 84 index.addDeclaration(variable.getNameToken(), fieldEntry);
85 return recurse(node, index); 85 return visitChildren(node, index);
86 } 86 }
87 87
88 @Override 88 @Override
@@ -91,6 +91,6 @@ public class SourceIndexClassVisitor extends SourceIndexVisitor {
91 FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION); 91 FieldDefinition def = node.getUserData(Keys.FIELD_DEFINITION);
92 FieldDefEntry fieldEntry = FieldDefEntry.parse(def); 92 FieldDefEntry fieldEntry = FieldDefEntry.parse(def);
93 index.addDeclaration(node.getNameToken(), fieldEntry); 93 index.addDeclaration(node.getNameToken(), fieldEntry);
94 return recurse(node, index); 94 return visitChildren(node, index);
95 } 95 }
96} 96}
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
index fde6edf..dfe58ba 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexMethodVisitor.java
@@ -63,7 +63,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
63 // Check for identifier 63 // Check for identifier
64 node.getArguments().stream().filter(expression -> expression instanceof IdentifierExpression) 64 node.getArguments().stream().filter(expression -> expression instanceof IdentifierExpression)
65 .forEach(expression -> this.checkIdentifier((IdentifierExpression) expression, index)); 65 .forEach(expression -> this.checkIdentifier((IdentifierExpression) expression, index));
66 return recurse(node, index); 66 return visitChildren(node, index);
67 } 67 }
68 68
69 @Override 69 @Override
@@ -81,7 +81,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
81 index.addReference(node.getMemberNameToken(), fieldEntry, this.methodEntry); 81 index.addReference(node.getMemberNameToken(), fieldEntry, this.methodEntry);
82 } 82 }
83 83
84 return recurse(node, index); 84 return visitChildren(node, index);
85 } 85 }
86 86
87 @Override 87 @Override
@@ -92,7 +92,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
92 index.addReference(node.getIdentifierToken(), classEntry, this.methodEntry); 92 index.addReference(node.getIdentifierToken(), classEntry, this.methodEntry);
93 } 93 }
94 94
95 return recurse(node, index); 95 return visitChildren(node, index);
96 } 96 }
97 97
98 @Override 98 @Override
@@ -107,14 +107,14 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
107 } 107 }
108 108
109 TypeDescriptor parameterType = TypeDescriptor.parse(def.getParameterType()); 109 TypeDescriptor parameterType = TypeDescriptor.parse(def.getParameterType());
110 LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, parameterIndex, node.getName(), true, parameterType); 110 LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, parameterIndex, node.getName(), true, parameterType, null);
111 Identifier identifier = node.getNameToken(); 111 Identifier identifier = node.getNameToken();
112 // cache the argument entry and the identifier 112 // cache the argument entry and the identifier
113 identifierEntryCache.put(identifier.getName(), localVariableEntry); 113 identifierEntryCache.put(identifier.getName(), localVariableEntry);
114 index.addDeclaration(identifier, localVariableEntry); 114 index.addDeclaration(identifier, localVariableEntry);
115 } 115 }
116 116
117 return recurse(node, index); 117 return visitChildren(node, index);
118 } 118 }
119 119
120 @Override 120 @Override
@@ -126,7 +126,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
126 index.addReference(node.getIdentifierToken(), fieldEntry, this.methodEntry); 126 index.addReference(node.getIdentifierToken(), fieldEntry, this.methodEntry);
127 } else 127 } else
128 this.checkIdentifier(node, index); 128 this.checkIdentifier(node, index);
129 return recurse(node, index); 129 return visitChildren(node, index);
130 } 130 }
131 131
132 private void checkIdentifier(IdentifierExpression node, SourceIndex index) { 132 private void checkIdentifier(IdentifierExpression node, SourceIndex index) {
@@ -157,7 +157,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
157 index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, this.methodEntry); 157 index.addReference(simpleTypeNode.getIdentifierToken(), constructorEntry, this.methodEntry);
158 } 158 }
159 159
160 return recurse(node, index); 160 return visitChildren(node, index);
161 } 161 }
162 162
163 @Override 163 @Override
@@ -177,7 +177,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
177 if (variableIndex >= 0) { 177 if (variableIndex >= 0) {
178 MethodDefEntry ownerMethod = MethodDefEntry.parse(originalVariable.getDeclaringMethod()); 178 MethodDefEntry ownerMethod = MethodDefEntry.parse(originalVariable.getDeclaringMethod());
179 TypeDescriptor variableType = TypeDescriptor.parse(originalVariable.getVariableType()); 179 TypeDescriptor variableType = TypeDescriptor.parse(originalVariable.getVariableType());
180 LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, variableIndex, initializer.getName(), false, variableType); 180 LocalVariableDefEntry localVariableEntry = new LocalVariableDefEntry(ownerMethod, variableIndex, initializer.getName(), false, variableType, null);
181 identifierEntryCache.put(identifier.getName(), localVariableEntry); 181 identifierEntryCache.put(identifier.getName(), localVariableEntry);
182 addDeclarationToUnmatched(identifier.getName(), index); 182 addDeclarationToUnmatched(identifier.getName(), index);
183 index.addDeclaration(identifier, localVariableEntry); 183 index.addDeclaration(identifier, localVariableEntry);
@@ -186,7 +186,7 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
186 } 186 }
187 } 187 }
188 } 188 }
189 return recurse(node, index); 189 return visitChildren(node, index);
190 } 190 }
191 191
192 @Override 192 @Override
@@ -211,6 +211,6 @@ public class SourceIndexMethodVisitor extends SourceIndexVisitor {
211 } 211 }
212 } 212 }
213 213
214 return recurse(node, index); 214 return visitChildren(node, index);
215 } 215 }
216} 216}
diff --git a/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
index 75a66a2..8bd00a8 100644
--- a/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/SourceIndexVisitor.java
@@ -12,11 +12,13 @@
12package cuchaz.enigma.analysis; 12package cuchaz.enigma.analysis;
13 13
14import com.strobel.assembler.metadata.TypeDefinition; 14import com.strobel.assembler.metadata.TypeDefinition;
15import com.strobel.decompiler.languages.java.ast.*; 15import com.strobel.decompiler.languages.java.ast.AstNode;
16import com.strobel.decompiler.patterns.Pattern; 16import com.strobel.decompiler.languages.java.ast.DepthFirstAstVisitor;
17import com.strobel.decompiler.languages.java.ast.Keys;
18import com.strobel.decompiler.languages.java.ast.TypeDeclaration;
17import cuchaz.enigma.translation.representation.entry.ClassDefEntry; 19import cuchaz.enigma.translation.representation.entry.ClassDefEntry;
18 20
19public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void> { 21public class SourceIndexVisitor extends DepthFirstAstVisitor<SourceIndex, Void> {
20 @Override 22 @Override
21 public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) { 23 public Void visitTypeDeclaration(TypeDeclaration node, SourceIndex index) {
22 TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION); 24 TypeDefinition def = node.getUserData(Keys.TYPE_DEFINITION);
@@ -26,355 +28,11 @@ public class SourceIndexVisitor implements IAstVisitor<SourceIndex, Void> {
26 return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index); 28 return node.acceptVisitor(new SourceIndexClassVisitor(classEntry), index);
27 } 29 }
28 30
29 protected Void recurse(AstNode node, SourceIndex index) { 31 @Override
32 protected Void visitChildren(AstNode node, SourceIndex index) {
30 for (final AstNode child : node.getChildren()) { 33 for (final AstNode child : node.getChildren()) {
31 child.acceptVisitor(this, index); 34 child.acceptVisitor(this, index);
32 } 35 }
33 return null; 36 return null;
34 } 37 }
35
36 @Override
37 public Void visitMethodDeclaration(MethodDeclaration node, SourceIndex index) {
38 return recurse(node, index);
39 }
40
41 @Override
42 public Void visitConstructorDeclaration(ConstructorDeclaration node, SourceIndex index) {
43 return recurse(node, index);
44 }
45
46 @Override
47 public Void visitFieldDeclaration(FieldDeclaration node, SourceIndex index) {
48 return recurse(node, index);
49 }
50
51 @Override
52 public Void visitEnumValueDeclaration(EnumValueDeclaration node, SourceIndex index) {
53 return recurse(node, index);
54 }
55
56 @Override
57 public Void visitParameterDeclaration(ParameterDeclaration node, SourceIndex index) {
58 return recurse(node, index);
59 }
60
61 @Override
62 public Void visitInvocationExpression(InvocationExpression node, SourceIndex index) {
63 return recurse(node, index);
64 }
65
66 @Override
67 public Void visitMemberReferenceExpression(MemberReferenceExpression node, SourceIndex index) {
68 return recurse(node, index);
69 }
70
71 @Override
72 public Void visitSimpleType(SimpleType node, SourceIndex index) {
73 return recurse(node, index);
74 }
75
76 @Override
77 public Void visitIdentifierExpression(IdentifierExpression node, SourceIndex index) {
78 return recurse(node, index);
79 }
80
81 @Override
82 public Void visitComment(Comment node, SourceIndex index) {
83 return recurse(node, index);
84 }
85
86 @Override
87 public Void visitPatternPlaceholder(AstNode node, Pattern pattern, SourceIndex index) {
88 return recurse(node, index);
89 }
90
91 @Override
92 public Void visitTypeReference(TypeReferenceExpression node, SourceIndex index) {
93 return recurse(node, index);
94 }
95
96 @Override
97 public Void visitJavaTokenNode(JavaTokenNode node, SourceIndex index) {
98 return recurse(node, index);
99 }
100
101 @Override
102 public Void visitIdentifier(Identifier node, SourceIndex index) {
103 return recurse(node, index);
104 }
105
106 @Override
107 public Void visitNullReferenceExpression(NullReferenceExpression node, SourceIndex index) {
108 return recurse(node, index);
109 }
110
111 @Override
112 public Void visitThisReferenceExpression(ThisReferenceExpression node, SourceIndex index) {
113 return recurse(node, index);
114 }
115
116 @Override
117 public Void visitSuperReferenceExpression(SuperReferenceExpression node, SourceIndex index) {
118 return recurse(node, index);
119 }
120
121 @Override
122 public Void visitClassOfExpression(ClassOfExpression node, SourceIndex index) {
123 return recurse(node, index);
124 }
125
126 @Override
127 public Void visitBlockStatement(BlockStatement node, SourceIndex index) {
128 return recurse(node, index);
129 }
130
131 @Override
132 public Void visitExpressionStatement(ExpressionStatement node, SourceIndex index) {
133 return recurse(node, index);
134 }
135
136 @Override
137 public Void visitBreakStatement(BreakStatement node, SourceIndex index) {
138 return recurse(node, index);
139 }
140
141 @Override
142 public Void visitContinueStatement(ContinueStatement node, SourceIndex index) {
143 return recurse(node, index);
144 }
145
146 @Override
147 public Void visitDoWhileStatement(DoWhileStatement node, SourceIndex index) {
148 return recurse(node, index);
149 }
150
151 @Override
152 public Void visitEmptyStatement(EmptyStatement node, SourceIndex index) {
153 return recurse(node, index);
154 }
155
156 @Override
157 public Void visitIfElseStatement(IfElseStatement node, SourceIndex index) {
158 return recurse(node, index);
159 }
160
161 @Override
162 public Void visitLabelStatement(LabelStatement node, SourceIndex index) {
163 return recurse(node, index);
164 }
165
166 @Override
167 public Void visitLabeledStatement(LabeledStatement node, SourceIndex index) {
168 return recurse(node, index);
169 }
170
171 @Override
172 public Void visitReturnStatement(ReturnStatement node, SourceIndex index) {
173 return recurse(node, index);
174 }
175
176 @Override
177 public Void visitSwitchStatement(SwitchStatement node, SourceIndex index) {
178 return recurse(node, index);
179 }
180
181 @Override
182 public Void visitSwitchSection(SwitchSection node, SourceIndex index) {
183 return recurse(node, index);
184 }
185
186 @Override
187 public Void visitCaseLabel(CaseLabel node, SourceIndex index) {
188 return recurse(node, index);
189 }
190
191 @Override
192 public Void visitThrowStatement(ThrowStatement node, SourceIndex index) {
193 return recurse(node, index);
194 }
195
196 @Override
197 public Void visitCatchClause(CatchClause node, SourceIndex index) {
198 return recurse(node, index);
199 }
200
201 @Override
202 public Void visitAnnotation(Annotation node, SourceIndex index) {
203 return recurse(node, index);
204 }
205
206 @Override
207 public Void visitNewLine(NewLineNode node, SourceIndex index) {
208 return recurse(node, index);
209 }
210
211 @Override
212 public Void visitVariableDeclaration(VariableDeclarationStatement node, SourceIndex index) {
213 return recurse(node, index);
214 }
215
216 @Override
217 public Void visitVariableInitializer(VariableInitializer node, SourceIndex index) {
218 return recurse(node, index);
219 }
220
221 @Override
222 public Void visitText(TextNode node, SourceIndex index) {
223 return recurse(node, index);
224 }
225
226 @Override
227 public Void visitImportDeclaration(ImportDeclaration node, SourceIndex index) {
228 return recurse(node, index);
229 }
230
231 @Override
232 public Void visitInitializerBlock(InstanceInitializer node, SourceIndex index) {
233 return recurse(node, index);
234 }
235
236 @Override
237 public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, SourceIndex index) {
238 return recurse(node, index);
239 }
240
241 @Override
242 public Void visitCompilationUnit(CompilationUnit node, SourceIndex index) {
243 return recurse(node, index);
244 }
245
246 @Override
247 public Void visitPackageDeclaration(PackageDeclaration node, SourceIndex index) {
248 return recurse(node, index);
249 }
250
251 @Override
252 public Void visitArraySpecifier(ArraySpecifier node, SourceIndex index) {
253 return recurse(node, index);
254 }
255
256 @Override
257 public Void visitComposedType(ComposedType node, SourceIndex index) {
258 return recurse(node, index);
259 }
260
261 @Override
262 public Void visitWhileStatement(WhileStatement node, SourceIndex index) {
263 return recurse(node, index);
264 }
265
266 @Override
267 public Void visitPrimitiveExpression(PrimitiveExpression node, SourceIndex index) {
268 return recurse(node, index);
269 }
270
271 @Override
272 public Void visitCastExpression(CastExpression node, SourceIndex index) {
273 return recurse(node, index);
274 }
275
276 @Override
277 public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, SourceIndex index) {
278 return recurse(node, index);
279 }
280
281 @Override
282 public Void visitInstanceOfExpression(InstanceOfExpression node, SourceIndex index) {
283 return recurse(node, index);
284 }
285
286 @Override
287 public Void visitIndexerExpression(IndexerExpression node, SourceIndex index) {
288 return recurse(node, index);
289 }
290
291 @Override
292 public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, SourceIndex index) {
293 return recurse(node, index);
294 }
295
296 @Override
297 public Void visitConditionalExpression(ConditionalExpression node, SourceIndex index) {
298 return recurse(node, index);
299 }
300
301 @Override
302 public Void visitArrayInitializerExpression(ArrayInitializerExpression node, SourceIndex index) {
303 return recurse(node, index);
304 }
305
306 @Override
307 public Void visitObjectCreationExpression(ObjectCreationExpression node, SourceIndex index) {
308 return recurse(node, index);
309 }
310
311 @Override
312 public Void visitArrayCreationExpression(ArrayCreationExpression node, SourceIndex index) {
313 return recurse(node, index);
314 }
315
316 @Override
317 public Void visitAssignmentExpression(AssignmentExpression node, SourceIndex index) {
318 return recurse(node, index);
319 }
320
321 @Override
322 public Void visitForStatement(ForStatement node, SourceIndex index) {
323 return recurse(node, index);
324 }
325
326 @Override
327 public Void visitForEachStatement(ForEachStatement node, SourceIndex index) {
328 return recurse(node, index);
329 }
330
331 @Override
332 public Void visitTryCatchStatement(TryCatchStatement node, SourceIndex index) {
333 return recurse(node, index);
334 }
335
336 @Override
337 public Void visitGotoStatement(GotoStatement node, SourceIndex index) {
338 return recurse(node, index);
339 }
340
341 @Override
342 public Void visitParenthesizedExpression(ParenthesizedExpression node, SourceIndex index) {
343 return recurse(node, index);
344 }
345
346 @Override
347 public Void visitSynchronizedStatement(SynchronizedStatement node, SourceIndex index) {
348 return recurse(node, index);
349 }
350
351 @Override
352 public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, SourceIndex index) {
353 return recurse(node, index);
354 }
355
356 @Override
357 public Void visitWildcardType(WildcardType node, SourceIndex index) {
358 return recurse(node, index);
359 }
360
361 @Override
362 public Void visitMethodGroupExpression(MethodGroupExpression node, SourceIndex index) {
363 return recurse(node, index);
364 }
365
366 @Override
367 public Void visitAssertStatement(AssertStatement node, SourceIndex index) {
368 return recurse(node, index);
369 }
370
371 @Override
372 public Void visitLambdaExpression(LambdaExpression node, SourceIndex index) {
373 return recurse(node, index);
374 }
375
376 @Override
377 public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, SourceIndex index) {
378 return recurse(node, index);
379 }
380} 38}
diff --git a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
index c98fb9e..c85d97a 100644
--- a/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
+++ b/src/main/java/cuchaz/enigma/analysis/TreeDumpVisitor.java
@@ -18,7 +18,7 @@ import com.strobel.decompiler.patterns.Pattern;
18import java.io.*; 18import java.io.*;
19import java.nio.charset.Charset; 19import java.nio.charset.Charset;
20 20
21public class TreeDumpVisitor implements IAstVisitor<Void, Void> { 21public class TreeDumpVisitor extends DepthFirstAstVisitor<Void, Void> {
22 22
23 private File file; 23 private File file;
24 private Writer out; 24 private Writer out;
@@ -31,7 +31,7 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
31 public Void visitCompilationUnit(CompilationUnit node, Void ignored) { 31 public Void visitCompilationUnit(CompilationUnit node, Void ignored) {
32 try { 32 try {
33 out = new OutputStreamWriter(new FileOutputStream(file), Charset.forName("UTF-8")); 33 out = new OutputStreamWriter(new FileOutputStream(file), Charset.forName("UTF-8"));
34 recurse(node, ignored); 34 visitChildren(node, ignored);
35 out.close(); 35 out.close();
36 return null; 36 return null;
37 } catch (IOException ex) { 37 } catch (IOException ex) {
@@ -39,7 +39,8 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
39 } 39 }
40 } 40 }
41 41
42 private Void recurse(AstNode node, Void ignored) { 42 @Override
43 protected Void visitChildren(AstNode node, Void ignored) {
43 // show the tree 44 // show the tree
44 try { 45 try {
45 out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n"); 46 out.write(getIndent(node) + node.getClass().getSimpleName() + " " + getText(node) + " " + dumpUserData(node) + " " + node.getRegion() + "\n");
@@ -89,351 +90,4 @@ public class TreeDumpVisitor implements IAstVisitor<Void, Void> {
89 } 90 }
90 return depth; 91 return depth;
91 } 92 }
92
93 // OVERRIDES WE DON'T CARE ABOUT
94
95 @Override
96 public Void visitInvocationExpression(InvocationExpression node, Void ignored) {
97 return recurse(node, ignored);
98 }
99
100 @Override
101 public Void visitMemberReferenceExpression(MemberReferenceExpression node, Void ignored) {
102 return recurse(node, ignored);
103 }
104
105 @Override
106 public Void visitSimpleType(SimpleType node, Void ignored) {
107 return recurse(node, ignored);
108 }
109
110 @Override
111 public Void visitMethodDeclaration(MethodDeclaration node, Void ignored) {
112 return recurse(node, ignored);
113 }
114
115 @Override
116 public Void visitConstructorDeclaration(ConstructorDeclaration node, Void ignored) {
117 return recurse(node, ignored);
118 }
119
120 @Override
121 public Void visitParameterDeclaration(ParameterDeclaration node, Void ignored) {
122 return recurse(node, ignored);
123 }
124
125 @Override
126 public Void visitFieldDeclaration(FieldDeclaration node, Void ignored) {
127 return recurse(node, ignored);
128 }
129
130 @Override
131 public Void visitTypeDeclaration(TypeDeclaration node, Void ignored) {
132 return recurse(node, ignored);
133 }
134
135 @Override
136 public Void visitComment(Comment node, Void ignored) {
137 return recurse(node, ignored);
138 }
139
140 @Override
141 public Void visitPatternPlaceholder(AstNode node, Pattern pattern, Void ignored) {
142 return recurse(node, ignored);
143 }
144
145 @Override
146 public Void visitTypeReference(TypeReferenceExpression node, Void ignored) {
147 return recurse(node, ignored);
148 }
149
150 @Override
151 public Void visitJavaTokenNode(JavaTokenNode node, Void ignored) {
152 return recurse(node, ignored);
153 }
154
155 @Override
156 public Void visitIdentifier(Identifier node, Void ignored) {
157 return recurse(node, ignored);
158 }
159
160 @Override
161 public Void visitNullReferenceExpression(NullReferenceExpression node, Void ignored) {
162 return recurse(node, ignored);
163 }
164
165 @Override
166 public Void visitThisReferenceExpression(ThisReferenceExpression node, Void ignored) {
167 return recurse(node, ignored);
168 }
169
170 @Override
171 public Void visitSuperReferenceExpression(SuperReferenceExpression node, Void ignored) {
172 return recurse(node, ignored);
173 }
174
175 @Override
176 public Void visitClassOfExpression(ClassOfExpression node, Void ignored) {
177 return recurse(node, ignored);
178 }
179
180 @Override
181 public Void visitBlockStatement(BlockStatement node, Void ignored) {
182 return recurse(node, ignored);
183 }
184
185 @Override
186 public Void visitExpressionStatement(ExpressionStatement node, Void ignored) {
187 return recurse(node, ignored);
188 }
189
190 @Override
191 public Void visitBreakStatement(BreakStatement node, Void ignored) {
192 return recurse(node, ignored);
193 }
194
195 @Override
196 public Void visitContinueStatement(ContinueStatement node, Void ignored) {
197 return recurse(node, ignored);
198 }
199
200 @Override
201 public Void visitDoWhileStatement(DoWhileStatement node, Void ignored) {
202 return recurse(node, ignored);
203 }
204
205 @Override
206 public Void visitEmptyStatement(EmptyStatement node, Void ignored) {
207 return recurse(node, ignored);
208 }
209
210 @Override
211 public Void visitIfElseStatement(IfElseStatement node, Void ignored) {
212 return recurse(node, ignored);
213 }
214
215 @Override
216 public Void visitLabelStatement(LabelStatement node, Void ignored) {
217 return recurse(node, ignored);
218 }
219
220 @Override
221 public Void visitLabeledStatement(LabeledStatement node, Void ignored) {
222 return recurse(node, ignored);
223 }
224
225 @Override
226 public Void visitReturnStatement(ReturnStatement node, Void ignored) {
227 return recurse(node, ignored);
228 }
229
230 @Override
231 public Void visitSwitchStatement(SwitchStatement node, Void ignored) {
232 return recurse(node, ignored);
233 }
234
235 @Override
236 public Void visitSwitchSection(SwitchSection node, Void ignored) {
237 return recurse(node, ignored);
238 }
239
240 @Override
241 public Void visitCaseLabel(CaseLabel node, Void ignored) {
242 return recurse(node, ignored);
243 }
244
245 @Override
246 public Void visitThrowStatement(ThrowStatement node, Void ignored) {
247 return recurse(node, ignored);
248 }
249
250 @Override
251 public Void visitCatchClause(CatchClause node, Void ignored) {
252 return recurse(node, ignored);
253 }
254
255 @Override
256 public Void visitAnnotation(Annotation node, Void ignored) {
257 return recurse(node, ignored);
258 }
259
260 @Override
261 public Void visitNewLine(NewLineNode node, Void ignored) {
262 return recurse(node, ignored);
263 }
264
265 @Override
266 public Void visitVariableDeclaration(VariableDeclarationStatement node, Void ignored) {
267 return recurse(node, ignored);
268 }
269
270 @Override
271 public Void visitVariableInitializer(VariableInitializer node, Void ignored) {
272 return recurse(node, ignored);
273 }
274
275 @Override
276 public Void visitText(TextNode node, Void ignored) {
277 return recurse(node, ignored);
278 }
279
280 @Override
281 public Void visitImportDeclaration(ImportDeclaration node, Void ignored) {
282 return recurse(node, ignored);
283 }
284
285 @Override
286 public Void visitInitializerBlock(InstanceInitializer node, Void ignored) {
287 return recurse(node, ignored);
288 }
289
290 @Override
291 public Void visitTypeParameterDeclaration(TypeParameterDeclaration node, Void ignored) {
292 return recurse(node, ignored);
293 }
294
295 @Override
296 public Void visitPackageDeclaration(PackageDeclaration node, Void ignored) {
297 return recurse(node, ignored);
298 }
299
300 @Override
301 public Void visitArraySpecifier(ArraySpecifier node, Void ignored) {
302 return recurse(node, ignored);
303 }
304
305 @Override
306 public Void visitComposedType(ComposedType node, Void ignored) {
307 return recurse(node, ignored);
308 }
309
310 @Override
311 public Void visitWhileStatement(WhileStatement node, Void ignored) {
312 return recurse(node, ignored);
313 }
314
315 @Override
316 public Void visitPrimitiveExpression(PrimitiveExpression node, Void ignored) {
317 return recurse(node, ignored);
318 }
319
320 @Override
321 public Void visitCastExpression(CastExpression node, Void ignored) {
322 return recurse(node, ignored);
323 }
324
325 @Override
326 public Void visitBinaryOperatorExpression(BinaryOperatorExpression node, Void ignored) {
327 return recurse(node, ignored);
328 }
329
330 @Override
331 public Void visitInstanceOfExpression(InstanceOfExpression node, Void ignored) {
332 return recurse(node, ignored);
333 }
334
335 @Override
336 public Void visitIndexerExpression(IndexerExpression node, Void ignored) {
337 return recurse(node, ignored);
338 }
339
340 @Override
341 public Void visitIdentifierExpression(IdentifierExpression node, Void ignored) {
342 return recurse(node, ignored);
343 }
344
345 @Override
346 public Void visitUnaryOperatorExpression(UnaryOperatorExpression node, Void ignored) {
347 return recurse(node, ignored);
348 }
349
350 @Override
351 public Void visitConditionalExpression(ConditionalExpression node, Void ignored) {
352 return recurse(node, ignored);
353 }
354
355 @Override
356 public Void visitArrayInitializerExpression(ArrayInitializerExpression node, Void ignored) {
357 return recurse(node, ignored);
358 }
359
360 @Override
361 public Void visitObjectCreationExpression(ObjectCreationExpression node, Void ignored) {
362 return recurse(node, ignored);
363 }
364
365 @Override
366 public Void visitArrayCreationExpression(ArrayCreationExpression node, Void ignored) {
367 return recurse(node, ignored);
368 }
369
370 @Override
371 public Void visitAssignmentExpression(AssignmentExpression node, Void ignored) {
372 return recurse(node, ignored);
373 }
374
375 @Override
376 public Void visitForStatement(ForStatement node, Void ignored) {
377 return recurse(node, ignored);
378 }
379
380 @Override
381 public Void visitForEachStatement(ForEachStatement node, Void ignored) {
382 return recurse(node, ignored);
383 }
384
385 @Override
386 public Void visitTryCatchStatement(TryCatchStatement node, Void ignored) {
387 return recurse(node, ignored);
388 }
389
390 @Override
391 public Void visitGotoStatement(GotoStatement node, Void ignored) {
392 return recurse(node, ignored);
393 }
394
395 @Override
396 public Void visitParenthesizedExpression(ParenthesizedExpression node, Void ignored) {
397 return recurse(node, ignored);
398 }
399
400 @Override
401 public Void visitSynchronizedStatement(SynchronizedStatement node, Void ignored) {
402 return recurse(node, ignored);
403 }
404
405 @Override
406 public Void visitAnonymousObjectCreationExpression(AnonymousObjectCreationExpression node, Void ignored) {
407 return recurse(node, ignored);
408 }
409
410 @Override
411 public Void visitWildcardType(WildcardType node, Void ignored) {
412 return recurse(node, ignored);
413 }
414
415 @Override
416 public Void visitMethodGroupExpression(MethodGroupExpression node, Void ignored) {
417 return recurse(node, ignored);
418 }
419
420 @Override
421 public Void visitEnumValueDeclaration(EnumValueDeclaration node, Void ignored) {
422 return recurse(node, ignored);
423 }
424
425 @Override
426 public Void visitAssertStatement(AssertStatement node, Void ignored) {
427 return recurse(node, ignored);
428 }
429
430 @Override
431 public Void visitLambdaExpression(LambdaExpression node, Void ignored) {
432 return recurse(node, ignored);
433 }
434
435 @Override
436 public Void visitLocalTypeDeclarationStatement(LocalTypeDeclarationStatement node, Void ignored) {
437 return recurse(node, ignored);
438 }
439} 93}
HIC SVNT DRACONES