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
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
|
package lombok.javac;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.processing.Messager;
import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
import lombok.core.AST;
import com.sun.source.util.Trees;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.JCTree.JCAnnotation;
import com.sun.tools.javac.tree.JCTree.JCBlock;
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
import com.sun.tools.javac.tree.JCTree.JCExpression;
import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
import com.sun.tools.javac.tree.JCTree.JCImport;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.tree.JCTree.JCStatement;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
public class JavacAST extends AST<JCTree> {
private final Messager messager;
private final Name.Table nameTable;
private final TreeMaker treeMaker;
private final Symtab symtab;
private final Log log;
public JavacAST(Trees trees, JavacProcessingEnvironment env, JCCompilationUnit top) {
super(top.sourcefile == null ? null : top.sourcefile.toString());
setTop(buildCompilationUnit(top));
this.messager = env.getMessager();
this.log = Log.instance(env.getContext());
this.nameTable = Name.Table.instance(env.getContext());
this.treeMaker = TreeMaker.instance(env.getContext());
this.symtab = Symtab.instance(env.getContext());
}
@Override public String getPackageDeclaration() {
JCCompilationUnit unit = (JCCompilationUnit)top().get();
return unit.pid instanceof JCFieldAccess ? unit.pid.toString() : null;
}
@Override public Collection<String> getImportStatements() {
List<String> imports = new ArrayList<String>();
JCCompilationUnit unit = (JCCompilationUnit)top().get();
for ( JCTree def : unit.defs ) {
if ( def instanceof JCImport ) {
imports.add(((JCImport)def).qualid.toString());
}
}
return imports;
}
public void traverse(JavacASTVisitor visitor) {
top().traverse(visitor);
}
private void traverseChildren(JavacASTVisitor visitor, Node node) {
for ( Node child : new ArrayList<Node>(node.down()) ) {
child.traverse(visitor);
}
}
@Override public Node top() {
return (Node) super.top();
}
@Override public Node get(JCTree astNode) {
return (Node) super.get(astNode);
}
public Name toName(String name) {
return nameTable.fromString(name);
}
public TreeMaker getTreeMaker() {
return treeMaker;
}
public Symtab getSymbolTable() {
return symtab;
}
@Override protected Node buildTree(JCTree node, Kind kind) {
switch ( kind ) {
case COMPILATION_UNIT:
return buildCompilationUnit((JCCompilationUnit) node);
case TYPE:
return buildType((JCClassDecl) node);
case FIELD:
return buildField((JCVariableDecl) node);
case INITIALIZER:
return buildInitializer((JCBlock) node);
case METHOD:
return buildMethod((JCMethodDecl) node);
case ARGUMENT:
return buildLocalVar((JCVariableDecl) node, kind);
case LOCAL:
return buildLocalVar((JCVariableDecl) node, kind);
case STATEMENT:
return buildStatementOrExpression(node);
case ANNOTATION:
return buildAnnotation((JCAnnotation) node);
default:
throw new AssertionError("Did not expect: " + kind);
}
}
private Node buildCompilationUnit(JCCompilationUnit top) {
List<Node> childNodes = new ArrayList<Node>();
for ( JCTree s : top.defs ) {
if ( s instanceof JCClassDecl ) {
addIfNotNull(childNodes, buildType((JCClassDecl)s));
} // else they are import statements, which we don't care about. Or Skip objects, whatever those are.
}
return new Node(top, childNodes, Kind.COMPILATION_UNIT);
}
private Node buildType(JCClassDecl type) {
if ( setAndGetAsHandled(type) ) return null;
List<Node> childNodes = new ArrayList<Node>();
for ( JCTree def : type.defs ) {
for ( JCAnnotation annotation : type.mods.annotations ) addIfNotNull(childNodes, buildAnnotation(annotation));
/* A def can be:
* JCClassDecl for inner types
* JCMethodDecl for constructors and methods
* JCVariableDecl for fields
* JCBlock for (static) initializers
*/
if ( def instanceof JCMethodDecl ) addIfNotNull(childNodes, buildMethod((JCMethodDecl)def));
else if ( def instanceof JCClassDecl ) addIfNotNull(childNodes, buildType((JCClassDecl)def));
else if ( def instanceof JCVariableDecl ) addIfNotNull(childNodes, buildField((JCVariableDecl)def));
else if ( def instanceof JCBlock ) addIfNotNull(childNodes, buildInitializer((JCBlock)def));
}
return putInMap(new Node(type, childNodes, Kind.TYPE));
}
private Node buildField(JCVariableDecl field) {
if ( setAndGetAsHandled(field) ) return null;
List<Node> childNodes = new ArrayList<Node>();
for ( JCAnnotation annotation : field.mods.annotations ) addIfNotNull(childNodes, buildAnnotation(annotation));
addIfNotNull(childNodes, buildExpression(field.init));
return putInMap(new Node(field, childNodes, Kind.FIELD));
}
private Node buildLocalVar(JCVariableDecl local, Kind kind) {
if ( setAndGetAsHandled(local) ) return null;
List<Node> childNodes = new ArrayList<Node>();
for ( JCAnnotation annotation : local.mods.annotations ) addIfNotNull(childNodes, buildAnnotation(annotation));
addIfNotNull(childNodes, buildExpression(local.init));
return putInMap(new Node(local, childNodes, kind));
}
private Node buildInitializer(JCBlock initializer) {
if ( setAndGetAsHandled(initializer) ) return null;
List<Node> childNodes = new ArrayList<Node>();
for ( JCStatement statement: initializer.stats ) addIfNotNull(childNodes, buildStatement(statement));
return putInMap(new Node(initializer, childNodes, Kind.INITIALIZER));
}
private Node buildMethod(JCMethodDecl method) {
if ( setAndGetAsHandled(method) ) return null;
List<Node> childNodes = new ArrayList<Node>();
for ( JCAnnotation annotation : method.mods.annotations ) addIfNotNull(childNodes, buildAnnotation(annotation));
for ( JCVariableDecl param : method.params ) addIfNotNull(childNodes, buildLocalVar(param, Kind.ARGUMENT));
if ( method.body != null && method.body.stats != null )
for ( JCStatement statement : method.body.stats ) addIfNotNull(childNodes, buildStatement(statement));
return putInMap(new Node(method, childNodes, Kind.METHOD));
}
private Node buildAnnotation(JCAnnotation annotation) {
if ( setAndGetAsHandled(annotation) ) return null;
return putInMap(new Node(annotation, null, Kind.ANNOTATION));
}
private Node buildExpression(JCExpression expression) {
return buildStatementOrExpression(expression);
}
private Node buildStatement(JCStatement statement) {
return buildStatementOrExpression(statement);
}
private Node buildStatementOrExpression(JCTree statement) {
if ( statement == null ) return null;
if ( statement instanceof JCAnnotation ) return null;
if ( statement instanceof JCClassDecl ) return buildType((JCClassDecl)statement);
if ( statement instanceof JCVariableDecl ) return buildLocalVar((JCVariableDecl)statement, Kind.LOCAL);
if ( setAndGetAsHandled(statement) ) return null;
return drill(statement);
}
private Node drill(JCTree statement) {
List<Node> childNodes = new ArrayList<Node>();
for ( FieldAccess fa : fieldsOf(statement.getClass()) ) childNodes.addAll(buildWithField(Node.class, statement, fa));
return putInMap(new Node(statement, childNodes, Kind.STATEMENT));
}
protected Collection<Class<? extends JCTree>> getStatementTypes() {
Collection<Class<? extends JCTree>> collection = new ArrayList<Class<? extends JCTree>>(2);
collection.add(JCStatement.class);
collection.add(JCExpression.class);
return collection;
}
private static void addIfNotNull(Collection<Node> nodes, Node node) {
if ( node != null ) nodes.add(node);
}
public class Node extends AST<JCTree>.Node {
public Node(JCTree node, List<Node> children, Kind kind) {
super(node, children, kind);
}
public void traverse(JavacASTVisitor visitor) {
switch ( this.getKind() ) {
case COMPILATION_UNIT:
visitor.visitCompilationUnit(this, (JCCompilationUnit)get());
traverseChildren(visitor, this);
visitor.endVisitCompilationUnit(this, (JCCompilationUnit)get());
break;
case TYPE:
visitor.visitType(this, (JCClassDecl)get());
traverseChildren(visitor, this);
visitor.endVisitType(this, (JCClassDecl)get());
break;
case FIELD:
visitor.visitField(this, (JCVariableDecl)get());
traverseChildren(visitor, this);
visitor.endVisitField(this, (JCVariableDecl)get());
break;
case METHOD:
visitor.visitMethod(this, (JCMethodDecl)get());
traverseChildren(visitor, this);
visitor.endVisitMethod(this, (JCMethodDecl)get());
break;
case INITIALIZER:
visitor.visitInitializer(this, (JCBlock)get());
traverseChildren(visitor, this);
visitor.endVisitInitializer(this, (JCBlock)get());
break;
case ARGUMENT:
JCMethodDecl parent = (JCMethodDecl) up().get();
visitor.visitMethodArgument(this, (JCVariableDecl)get(), parent);
traverseChildren(visitor, this);
visitor.endVisitMethodArgument(this, (JCVariableDecl)get(), parent);
break;
case LOCAL:
visitor.visitLocal(this, (JCVariableDecl)get());
traverseChildren(visitor, this);
visitor.endVisitLocal(this, (JCVariableDecl)get());
break;
case STATEMENT:
visitor.visitStatement(this, (JCTree)get());
traverseChildren(visitor, this);
visitor.endVisitStatement(this, (JCTree)get());
break;
case ANNOTATION:
switch ( up().getKind() ) {
case TYPE:
visitor.visitAnnotationOnType((JCClassDecl)up().get(), this, (JCAnnotation)get());
break;
case FIELD:
visitor.visitAnnotationOnField((JCVariableDecl)up().get(), this, (JCAnnotation)get());
break;
case METHOD:
visitor.visitAnnotationOnMethod((JCMethodDecl)up().get(), this, (JCAnnotation)get());
break;
case ARGUMENT:
JCVariableDecl argument = (JCVariableDecl)up().get();
JCMethodDecl method = (JCMethodDecl)up().up().get();
visitor.visitAnnotationOnMethodArgument(argument, method, this, (JCAnnotation)get());
break;
case LOCAL:
visitor.visitAnnotationOnLocal((JCVariableDecl)up().get(), this, (JCAnnotation)get());
break;
default:
throw new AssertionError("Annotion not expected as child of a " + up().getKind());
}
break;
default:
throw new AssertionError("Unexpected kind during node traversal: " + getKind());
}
}
@Override public String getName() {
final Name n;
if ( node instanceof JCClassDecl ) n = ((JCClassDecl)node).name;
else if ( node instanceof JCMethodDecl ) n = ((JCMethodDecl)node).name;
else if ( node instanceof JCVariableDecl ) n = ((JCVariableDecl)node).name;
else n = null;
return n == null ? null : n.toString();
}
@Override protected boolean calculateIsStructurallySignificant() {
if ( node instanceof JCClassDecl ) return true;
if ( node instanceof JCMethodDecl ) return true;
if ( node instanceof JCVariableDecl ) return true;
if ( node instanceof JCCompilationUnit ) return true;
return false;
}
public TreeMaker getTreeMaker() {
return treeMaker;
}
public Symtab getSymbolTable() {
return symtab;
}
public Name toName(String name) {
return JavacAST.this.toName(name);
}
/** {@inheritDoc} */
@Override public Node getNodeFor(JCTree obj) {
return (Node) super.getNodeFor(obj);
}
/** {@inheritDoc} */
@Override public Node directUp() {
return (Node) super.directUp();
}
/** {@inheritDoc} */
@Override public Node up() {
return (Node) super.up();
}
/** {@inheritDoc} */
@Override public Node top() {
return (Node) super.top();
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public Collection<Node> down() {
return (Collection<Node>) super.down();
}
public void addError(String message) {
printMessage(Diagnostic.Kind.ERROR, message, this, null);
}
public void addError(String message, DiagnosticPosition pos) {
printMessage(Diagnostic.Kind.ERROR, message, null, pos);
}
public void addWarning(String message) {
printMessage(Diagnostic.Kind.WARNING, message, this, null);
}
public void addWarning(String message, DiagnosticPosition pos) {
printMessage(Diagnostic.Kind.WARNING, message, null, pos);
}
}
/** Supply either a position or a node (in that case, position of the node is used) */
private void printMessage(Diagnostic.Kind kind, String message, Node node, DiagnosticPosition pos) {
JavaFileObject oldSource = null;
JavaFileObject newSource = null;
JCTree astObject = node == null ? null : node.get();
JCCompilationUnit top = (JCCompilationUnit) top().get();
newSource = top.sourcefile;
if (newSource != null) {
oldSource = log.useSource(newSource);
if ( pos == null ) pos = astObject.pos();
}
try {
switch (kind) {
case ERROR:
increaseErrorCount(messager);
boolean prev = log.multipleErrors;
log.multipleErrors = true;
try {
log.error(pos, "proc.messager", message);
} finally {
log.multipleErrors = prev;
}
break;
default:
case WARNING:
log.warning(pos, "proc.messager", message);
break;
}
} finally {
if (oldSource != null)
log.useSource(oldSource);
}
}
@SuppressWarnings("unchecked")
@Override protected void setElementInASTCollection(Field field, Object refField, List<Collection<?>> chain, Collection<?> collection, int idx, JCTree newN) throws IllegalAccessException {
com.sun.tools.javac.util.List<?> list = setElementInConsList(chain, collection, ((List)collection).get(idx), newN);
field.set(refField, list);
}
private com.sun.tools.javac.util.List<?> setElementInConsList(List<Collection<?>> chain, Collection<?> current, Object oldO, Object newO) {
com.sun.tools.javac.util.List<?> oldL = (com.sun.tools.javac.util.List<?>) current;
com.sun.tools.javac.util.List<?> newL = replaceInConsList(oldL, oldO, newO);
if ( chain.isEmpty() ) return newL;
else {
List<Collection<?>> reducedChain = new ArrayList<Collection<?>>(chain);
Collection<?> newCurrent = reducedChain.remove(reducedChain.size() -1);
return setElementInConsList(reducedChain, newCurrent, oldL, newL);
}
}
private com.sun.tools.javac.util.List<?> replaceInConsList(com.sun.tools.javac.util.List<?> oldL, Object oldO, Object newO) {
boolean repl = false;
Object[] a = oldL.toArray();
for ( int i = 0 ; i < a.length ; i++ ) {
if ( a[i] == oldO ) {
a[i] = newO;
repl = true;
}
}
if ( repl ) return com.sun.tools.javac.util.List.<Object>from(a);
else return oldL;
}
private void increaseErrorCount(Messager messager) {
try {
Field f = messager.getClass().getDeclaredField("errorCount");
f.setAccessible(true);
if ( f.getType() == int.class ) {
int val = ((Number)f.get(messager)).intValue();
f.set(messager, val +1);
}
} catch ( Throwable t ) {
//Very unfortunate, but in most cases it still works fine, so we'll silently swallow it.
}
}
}
|