1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
package lombok.eclipse;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.lang.reflect.Modifier;
import lombok.eclipse.EclipseAST.Node;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Initializer;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
//TODO expand javadoc
public interface EclipseASTVisitor {
/**
* Called at the very beginning and end.
*/
void visitCompilationUnit(Node top, CompilationUnitDeclaration unit);
void endVisitCompilationUnit(Node top, CompilationUnitDeclaration unit);
/**
* Called when visiting a type (a class, interface, annotation, enum, etcetera).
*/
void visitType(Node typeNode, TypeDeclaration type);
void visitAnnotationOnType(TypeDeclaration type, Node annotationNode, Annotation annotation);
void endVisitType(Node typeNode, TypeDeclaration type);
/**
* Called when visiting a field of a class.
* Even though in eclipse initializers (both instance and static) are represented as Initializer objects,
* which are a subclass of FieldDeclaration, those do NOT result in a call to this method. They result
* in a call to the visitInitializer method.
*/
void visitField(Node fieldNode, FieldDeclaration field);
void visitAnnotationOnField(FieldDeclaration field, Node annotationNode, Annotation annotation);
void endVisitField(Node fieldNode, FieldDeclaration field);
/**
* Called for static and instance initializers. You can tell the difference via the modifier flag on the
* ASTNode (8 for static, 0 for not static). The content is in the 'block', not in the 'initialization',
* which would always be null for an initializer instance.
*/
void visitInitializer(Node initializerNode, Initializer initializer);
void endVisitInitializer(Node initializerNode, Initializer initializer);
/**
* Called for both methods (MethodDeclaration) and constructors (ConstructorDeclaration), but not for
* Clinit objects, which are a vestigial eclipse thing that never contain anything. Static initializers
* show up as 'Initializer', in the visitInitializer method, with modifier bit STATIC set.
*/
void visitMethod(Node methodNode, AbstractMethodDeclaration method);
void visitAnnotationOnMethod(AbstractMethodDeclaration method, Node annotationNode, Annotation annotation);
void endVisitMethod(Node methodNode, AbstractMethodDeclaration method);
/**
* Visits a method argument
*/
void visitMethodArgument(Node argNode, Argument arg, AbstractMethodDeclaration method);
void visitAnnotationOnMethodArgument(Argument arg, AbstractMethodDeclaration method, Node annotationNode, Annotation annotation);
void endVisitMethodArgument(Node argNode, Argument arg, AbstractMethodDeclaration method);
/**
* Visits a local declaration - that is, something like 'int x = 10;' on the method level.
*/
void visitLocal(Node localNode, LocalDeclaration local);
void visitAnnotationOnLocal(LocalDeclaration local, Node annotationNode, Annotation annotation);
void endVisitLocal(Node localNode, LocalDeclaration local);
/**
* Visits a statement that isn't any of the other visit methods (e.g. TypeDeclaration).
*/
void visitStatement(Node statementNode, Statement statement);
void endVisitStatement(Node statementNode, Statement statement);
public static class Printer implements EclipseASTVisitor {
private final PrintStream out;
public Printer() {
this(System.out);
}
public Printer(File file) throws FileNotFoundException {
this(new PrintStream(file));
}
public Printer(PrintStream out) {
this.out = out;
}
int indent = 0;
private void print(String text, Object... params) {
StringBuilder sb = new StringBuilder();
for ( int i = 0 ; i < indent ; i++ ) sb.append(" ");
out.printf(sb.append(text).append('\n').toString(), params);
out.flush();
}
private String str(char[] c) {
if ( c == null ) return "(NULL)";
else return new String(c);
}
private String str(TypeReference type) {
if ( type == null ) return "(NULL)";
char[][] c = type.getTypeName();
StringBuilder sb = new StringBuilder();
boolean first = true;
for ( char[] d : c ) {
sb.append(first ? "" : ".").append(new String(d));
first = false;
}
return sb.toString();
}
@Override public void visitCompilationUnit(Node node, CompilationUnitDeclaration unit) {
out.println("---------------------------------------------------------");
out.println(node.isCompleteParse() ? "COMPLETE" : "incomplete");
print("<CUD %s>", node.getFileName());
indent++;
}
@Override public void endVisitCompilationUnit(Node node, CompilationUnitDeclaration unit) {
indent--;
print("</CUD>");
}
@Override public void visitType(Node node, TypeDeclaration type) {
print("<TYPE %s>", str(type.name));
indent++;
}
@Override public void visitAnnotationOnType(TypeDeclaration type, Node node, Annotation annotation) {
print("<ANNOTATION: %s />", annotation);
}
@Override public void endVisitType(Node node, TypeDeclaration type) {
indent--;
print("</TYPE %s>", str(type.name));
}
@Override public void visitInitializer(Node node, Initializer initializer) {
Block block = initializer.block;
boolean s = (block != null && block.statements != null);
print("<%s INITIALIZER: %s>",
(initializer.modifiers & Modifier.STATIC) != 0 ? "static" : "instance",
s ? "filled" : "blank");
indent++;
}
@Override public void endVisitInitializer(Node node, Initializer initializer) {
indent--;
print("</%s INITIALIZER>", (initializer.modifiers & Modifier.STATIC) != 0 ? "static" : "instance");
}
@Override public void visitField(Node node, FieldDeclaration field) {
print("<FIELD %s %s = %s>", str(field.type), str(field.name), field.initialization);
indent++;
}
@Override public void visitAnnotationOnField(FieldDeclaration field, Node node, Annotation annotation) {
print("<ANNOTATION: %s />", annotation);
}
@Override public void endVisitField(Node node, FieldDeclaration field) {
indent--;
print("</FIELD %s %s>", str(field.type), str(field.name));
}
@Override public void visitMethod(Node node, AbstractMethodDeclaration method) {
String type = method instanceof ConstructorDeclaration ? "CONSTRUCTOR" : "METHOD";
print("<%s %s: %s>", type, str(method.selector), method.statements != null ? "filled" : "blank");
indent++;
}
@Override public void visitAnnotationOnMethod(AbstractMethodDeclaration method, Node node, Annotation annotation) {
print("<ANNOTATION: %s />", annotation);
}
@Override public void endVisitMethod(Node node, AbstractMethodDeclaration method) {
String type = method instanceof ConstructorDeclaration ? "CONSTRUCTOR" : "METHOD";
indent--;
print("</%s %s>", type, str(method.selector));
}
@Override public void visitMethodArgument(Node node, Argument arg, AbstractMethodDeclaration method) {
print("<METHODARG %s %s = %s>", str(arg.type), str(arg.name), arg.initialization);
indent++;
}
@Override public void visitAnnotationOnMethodArgument(Argument arg, AbstractMethodDeclaration method, Node node, Annotation annotation) {
print("<ANNOTATION: %s />", annotation);
}
@Override public void endVisitMethodArgument(Node node, Argument arg, AbstractMethodDeclaration method) {
indent--;
print("</METHODARG %s %s>", str(arg.type), str(arg.name));
}
@Override public void visitLocal(Node node, LocalDeclaration local) {
print("<LOCAL %s %s = %s>", str(local.type), str(local.name), local.initialization);
indent++;
}
@Override public void visitAnnotationOnLocal(LocalDeclaration local, Node node, Annotation annotation) {
print("<ANNOTATION: %s />", annotation);
}
@Override public void endVisitLocal(Node node, LocalDeclaration local) {
indent--;
print("</LOCAL %s %s>", str(local.type), str(local.name));
}
@Override public void visitStatement(Node node, Statement statement) {
print("<%s>", statement.getClass());
indent++;
print("%s", statement);
}
@Override public void endVisitStatement(Node node, Statement statement) {
indent--;
print("</%s>", statement.getClass());
}
}
}
|
