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 | |
package com.sun.tools.javafx.tree; |
27 | |
|
28 | |
import com.sun.tools.javac.tree.TreeInfo; |
29 | |
import com.sun.tools.javac.tree.JCTree; |
30 | |
|
31 | |
import com.sun.source.tree.Tree; |
32 | |
import java.util.Map; |
33 | |
import com.sun.tools.javac.util.*; |
34 | |
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; |
35 | |
import com.sun.tools.javac.code.*; |
36 | |
import com.sun.tools.javac.tree.JCTree.*; |
37 | |
|
38 | |
|
39 | |
|
40 | |
|
41 | |
|
42 | |
|
43 | |
|
44 | |
|
45 | |
public class JavafxTreeInfo extends TreeInfo { |
46 | |
|
47 | |
public static void preRegister(final Context context) { |
48 | 798 | context.put(treeInfoKey, new Context.Factory<TreeInfo>() { |
49 | |
public TreeInfo make() { |
50 | 399 | return new JavafxTreeInfo(context); |
51 | |
} |
52 | |
}); |
53 | 399 | } |
54 | |
|
55 | |
protected JavafxTreeInfo(Context context) { |
56 | 399 | super(context); |
57 | |
|
58 | 399 | Name.Table names = Name.Table.instance(context); |
59 | 399 | opname = new Name[JavafxTag.JFX_OP_LAST - JCTree.POS + 1]; |
60 | 399 | opname[JCTree.POS - JCTree.POS] = names.fromString("+"); |
61 | 399 | opname[JCTree.NEG - JCTree.POS] = names.hyphen; |
62 | 399 | opname[JCTree.NOT - JCTree.POS] = names.fromString("!"); |
63 | 399 | opname[JCTree.COMPL - JCTree.POS] = names.fromString("~"); |
64 | 399 | opname[JCTree.PREINC - JCTree.POS] = names.fromString("++"); |
65 | 399 | opname[JCTree.PREDEC - JCTree.POS] = names.fromString("--"); |
66 | 399 | opname[JCTree.POSTINC - JCTree.POS] = names.fromString("++"); |
67 | 399 | opname[JCTree.POSTDEC - JCTree.POS] = names.fromString("--"); |
68 | 399 | opname[JCTree.NULLCHK - JCTree.POS] = names.fromString("<*nullchk*>"); |
69 | 399 | opname[JCTree.OR - JCTree.POS] = names.fromString("or"); |
70 | 399 | opname[JCTree.AND - JCTree.POS] = names.fromString("and"); |
71 | 399 | opname[JCTree.EQ - JCTree.POS] = names.fromString("=="); |
72 | 399 | opname[JCTree.NE - JCTree.POS] = names.fromString("<>"); |
73 | 399 | opname[JCTree.LT - JCTree.POS] = names.fromString("<"); |
74 | 399 | opname[JCTree.GT - JCTree.POS] = names.fromString(">"); |
75 | 399 | opname[JCTree.LE - JCTree.POS] = names.fromString("<="); |
76 | 399 | opname[JCTree.GE - JCTree.POS] = names.fromString(">="); |
77 | 399 | opname[JCTree.SL - JCTree.POS] = names.fromString("<<"); |
78 | 399 | opname[JCTree.SR - JCTree.POS] = names.fromString(">>"); |
79 | 399 | opname[JCTree.USR - JCTree.POS] = names.fromString(">>>"); |
80 | 399 | opname[JCTree.PLUS - JCTree.POS] = names.fromString("+"); |
81 | 399 | opname[JCTree.MINUS - JCTree.POS] = names.hyphen; |
82 | 399 | opname[JCTree.MUL - JCTree.POS] = names.asterisk; |
83 | 399 | opname[JCTree.DIV - JCTree.POS] = names.slash; |
84 | 399 | opname[JCTree.MOD - JCTree.POS] = names.fromString("%"); |
85 | 399 | opname[JavafxTag.XOR - JCTree.POS] = names.fromString("xor"); |
86 | 399 | opname[JavafxTag.SIZEOF - JCTree.POS] = names.fromString("sizeof"); |
87 | 399 | opname[JavafxTag.INDEXOF - JCTree.POS] = names.fromString("indexof"); |
88 | 399 | opname[JavafxTag.REVERSE - JCTree.POS] = names.fromString("reverse"); |
89 | 399 | } |
90 | |
|
91 | |
|
92 | |
|
93 | |
|
94 | |
|
95 | |
public static DiagnosticPosition diagEndPos(final JCTree tree) { |
96 | 0 | final int endPos = JavafxTreeInfo.endPos(tree); |
97 | 0 | return new DiagnosticPosition() { |
98 | 0 | public JCTree getTree() { return tree; } |
99 | 0 | public int getStartPosition() { return JavafxTreeInfo.getStartPos(tree); } |
100 | 0 | public int getPreferredPosition() { return endPos; } |
101 | |
public int getEndPosition(Map<JCTree, Integer> endPosTable) { |
102 | 0 | return JavafxTreeInfo.getEndPos(tree, endPosTable); |
103 | |
} |
104 | |
}; |
105 | |
} |
106 | |
|
107 | |
public static DiagnosticPosition diagnosticPositionFor(final Symbol sym, final JCTree tree) { |
108 | 0 | JCTree decl = declarationFor(sym, tree); |
109 | 0 | return ((decl != null) ? decl : tree).pos(); |
110 | |
} |
111 | |
|
112 | |
|
113 | |
|
114 | |
public static JCTree declarationFor(final Symbol sym, final JCTree tree) { |
115 | 0 | class DeclScanner extends JavafxTreeScanner { |
116 | 0 | JCTree result = null; |
117 | |
@Override |
118 | |
public void scan(JCTree tree) { |
119 | 0 | if (tree!=null && result==null) |
120 | 0 | tree.accept(this); |
121 | 0 | } |
122 | |
@Override |
123 | |
public void visitTopLevel(JCCompilationUnit that) { |
124 | 0 | if (that.packge == sym) result = that; |
125 | 0 | else super.visitTopLevel(that); |
126 | 0 | } |
127 | |
@Override |
128 | |
public void visitClassDef(JCClassDecl that) { |
129 | 0 | if (that.sym == sym) result = that; |
130 | 0 | else super.visitClassDef(that); |
131 | 0 | } |
132 | |
@Override |
133 | |
public void visitFunctionDefinition(JFXFunctionDefinition that) { |
134 | 0 | if (that.sym == sym) result = that; |
135 | 0 | else super.visitFunctionDefinition(that); |
136 | 0 | } |
137 | |
@Override |
138 | |
public void visitMethodDef(JCMethodDecl that) { |
139 | 0 | if (that.sym == sym) result = that; |
140 | 0 | else super.visitMethodDef(that); |
141 | 0 | } |
142 | |
@Override |
143 | |
public void visitVar(JFXVar that) { |
144 | 0 | if (that.sym == sym) result = that; |
145 | 0 | else super.visitVar(that); |
146 | 0 | } |
147 | |
@Override |
148 | |
public void visitVarDef(JCVariableDecl that) { |
149 | 0 | if (that.sym == sym) result = that; |
150 | 0 | else super.visitVarDef(that); |
151 | 0 | } |
152 | |
} |
153 | 0 | DeclScanner s = new DeclScanner(); |
154 | 0 | tree.accept(s); |
155 | 0 | return s.result; |
156 | |
} |
157 | |
|
158 | |
public static List<JCTree> pathFor(final JCTree node, final JCCompilationUnit unit) { |
159 | |
class Result extends Error { |
160 | |
static final long serialVersionUID = -5942088234594905625L; |
161 | |
List<JCTree> path; |
162 | 0 | Result(List<JCTree> path) { |
163 | 0 | this.path = path; |
164 | 0 | } |
165 | |
} |
166 | 0 | class PathFinder extends JavafxTreeScanner { |
167 | 0 | List<JCTree> path = List.nil(); |
168 | |
public void scan(JCTree tree) { |
169 | 0 | if (tree != null) { |
170 | 0 | path = path.prepend(tree); |
171 | 0 | if (tree == node) |
172 | 0 | throw new Result(path); |
173 | 0 | super.scan(tree); |
174 | 0 | path = path.tail; |
175 | |
} |
176 | 0 | } |
177 | |
} |
178 | |
try { |
179 | 0 | new PathFinder().scan(unit); |
180 | 0 | } catch (Result result) { |
181 | 0 | return result.path; |
182 | 0 | } |
183 | 0 | return List.nil(); |
184 | |
} |
185 | |
|
186 | |
|
187 | |
|
188 | |
public static final int |
189 | |
notExpression = -1, |
190 | |
noPrec = 0, |
191 | |
assignPrec = 1, |
192 | |
assignopPrec = 2, |
193 | |
orPrec = 3, |
194 | |
andPrec = 4, |
195 | |
eqPrec = 5, |
196 | |
ordPrec = 6, |
197 | |
addPrec = 7, |
198 | |
mulPrec = 8, |
199 | |
prefixPrec = 9, |
200 | |
postfixPrec = 10, |
201 | |
precCount = 11; |
202 | |
|
203 | |
|
204 | |
|
205 | |
|
206 | |
public static int opPrec(int op) { |
207 | 0 | switch(op) { |
208 | |
case JCTree.ASSIGN: |
209 | 0 | return assignPrec; |
210 | |
case JCTree.USR_ASG: |
211 | |
case JCTree.PLUS_ASG: |
212 | |
case JCTree.MINUS_ASG: |
213 | |
case JCTree.MUL_ASG: |
214 | |
case JCTree.DIV_ASG: |
215 | |
case JCTree.MOD_ASG: |
216 | 0 | return assignopPrec; |
217 | |
case JCTree.OR: |
218 | |
case JavafxTag.XOR: |
219 | 0 | return orPrec; |
220 | |
case JCTree.AND: |
221 | 0 | return andPrec; |
222 | |
case JCTree.EQ: |
223 | |
case JCTree.NE: |
224 | 0 | return eqPrec; |
225 | |
case JCTree.LT: |
226 | |
case JCTree.GT: |
227 | |
case JCTree.LE: |
228 | |
case JCTree.GE: |
229 | 0 | return ordPrec; |
230 | |
case JCTree.PLUS: |
231 | |
case JCTree.MINUS: |
232 | 0 | return addPrec; |
233 | |
case JCTree.MUL: |
234 | |
case JCTree.DIV: |
235 | |
case JCTree.MOD: |
236 | 0 | return mulPrec; |
237 | |
case JCTree.TYPETEST: |
238 | 0 | return ordPrec; |
239 | |
case JCTree.POS: |
240 | |
case JCTree.NEG: |
241 | |
case JCTree.NOT: |
242 | |
case JCTree.COMPL: |
243 | |
case JCTree.PREINC: |
244 | |
case JCTree.PREDEC: |
245 | 0 | return prefixPrec; |
246 | |
case JCTree.POSTINC: |
247 | |
case JCTree.POSTDEC: |
248 | |
case JCTree.NULLCHK: |
249 | 0 | return postfixPrec; |
250 | 0 | default: throw new AssertionError(); |
251 | |
} |
252 | |
} |
253 | |
|
254 | |
static Tree.Kind tagToKind(int tag) { |
255 | 0 | switch (tag) { |
256 | |
|
257 | |
case JCTree.POSTINC: |
258 | 0 | return Tree.Kind.POSTFIX_INCREMENT; |
259 | |
case JCTree.POSTDEC: |
260 | 0 | return Tree.Kind.POSTFIX_DECREMENT; |
261 | |
|
262 | |
|
263 | |
case JCTree.PREINC: |
264 | 0 | return Tree.Kind.PREFIX_INCREMENT; |
265 | |
case JCTree.PREDEC: |
266 | 0 | return Tree.Kind.PREFIX_DECREMENT; |
267 | |
case JCTree.POS: |
268 | 0 | return Tree.Kind.UNARY_PLUS; |
269 | |
case JCTree.NEG: |
270 | 0 | return Tree.Kind.UNARY_MINUS; |
271 | |
case JCTree.COMPL: |
272 | 0 | return Tree.Kind.BITWISE_COMPLEMENT; |
273 | |
case JCTree.NOT: |
274 | 0 | return Tree.Kind.LOGICAL_COMPLEMENT; |
275 | |
|
276 | |
|
277 | |
|
278 | |
|
279 | |
case JCTree.MUL: |
280 | 0 | return Tree.Kind.MULTIPLY; |
281 | |
case JCTree.DIV: |
282 | 0 | return Tree.Kind.DIVIDE; |
283 | |
case JCTree.MOD: |
284 | 0 | return Tree.Kind.REMAINDER; |
285 | |
|
286 | |
|
287 | |
case JCTree.PLUS: |
288 | 0 | return Tree.Kind.PLUS; |
289 | |
case JCTree.MINUS: |
290 | 0 | return Tree.Kind.MINUS; |
291 | |
|
292 | |
|
293 | |
case JCTree.SL: |
294 | 0 | return Tree.Kind.LEFT_SHIFT; |
295 | |
case JCTree.SR: |
296 | 0 | return Tree.Kind.RIGHT_SHIFT; |
297 | |
case JCTree.USR: |
298 | 0 | return Tree.Kind.UNSIGNED_RIGHT_SHIFT; |
299 | |
|
300 | |
|
301 | |
case JCTree.LT: |
302 | 0 | return Tree.Kind.LESS_THAN; |
303 | |
case JCTree.GT: |
304 | 0 | return Tree.Kind.GREATER_THAN; |
305 | |
case JCTree.LE: |
306 | 0 | return Tree.Kind.LESS_THAN_EQUAL; |
307 | |
case JCTree.GE: |
308 | 0 | return Tree.Kind.GREATER_THAN_EQUAL; |
309 | |
|
310 | |
|
311 | |
case JCTree.EQ: |
312 | 0 | return Tree.Kind.EQUAL_TO; |
313 | |
case JCTree.NE: |
314 | 0 | return Tree.Kind.NOT_EQUAL_TO; |
315 | |
|
316 | |
|
317 | |
case JCTree.BITAND: |
318 | 0 | return Tree.Kind.AND; |
319 | |
case JCTree.BITXOR: |
320 | 0 | return Tree.Kind.XOR; |
321 | |
case JCTree.BITOR: |
322 | 0 | return Tree.Kind.OR; |
323 | |
|
324 | |
|
325 | |
case JCTree.AND: |
326 | 0 | return Tree.Kind.CONDITIONAL_AND; |
327 | |
case JCTree.OR: |
328 | 0 | return Tree.Kind.CONDITIONAL_OR; |
329 | |
|
330 | |
|
331 | |
case JCTree.MUL_ASG: |
332 | 0 | return Tree.Kind.MULTIPLY_ASSIGNMENT; |
333 | |
case JCTree.DIV_ASG: |
334 | 0 | return Tree.Kind.DIVIDE_ASSIGNMENT; |
335 | |
case JCTree.MOD_ASG: |
336 | 0 | return Tree.Kind.REMAINDER_ASSIGNMENT; |
337 | |
case JCTree.PLUS_ASG: |
338 | 0 | return Tree.Kind.PLUS_ASSIGNMENT; |
339 | |
case JCTree.MINUS_ASG: |
340 | 0 | return Tree.Kind.MINUS_ASSIGNMENT; |
341 | |
case JCTree.SL_ASG: |
342 | 0 | return Tree.Kind.LEFT_SHIFT_ASSIGNMENT; |
343 | |
case JCTree.SR_ASG: |
344 | 0 | return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT; |
345 | |
case JCTree.USR_ASG: |
346 | 0 | return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT; |
347 | |
case JCTree.BITAND_ASG: |
348 | 0 | return Tree.Kind.AND_ASSIGNMENT; |
349 | |
case JCTree.BITXOR_ASG: |
350 | 0 | return Tree.Kind.XOR_ASSIGNMENT; |
351 | |
case JCTree.BITOR_ASG: |
352 | 0 | return Tree.Kind.OR_ASSIGNMENT; |
353 | |
|
354 | |
|
355 | |
case JCTree.NULLCHK: |
356 | 0 | return Tree.Kind.OTHER; |
357 | |
|
358 | |
|
359 | |
case JavafxTag.SIZEOF: |
360 | 0 | return Tree.Kind.OTHER; |
361 | |
case JavafxTag.REVERSE: |
362 | 0 | return Tree.Kind.OTHER; |
363 | |
|
364 | |
default: |
365 | 0 | return null; |
366 | |
} |
367 | |
} |
368 | |
|
369 | |
|
370 | |
|
371 | |
public static Symbol symbol(JCTree tree) { |
372 | 2275 | tree = skipParens(tree); |
373 | 2275 | switch (tree.getTag()) { |
374 | |
case JCTree.IDENT: |
375 | 1443 | return ((JCIdent) tree).sym; |
376 | |
case JCTree.SELECT: |
377 | 760 | return ((JCFieldAccess) tree).sym; |
378 | |
case JCTree.TYPEAPPLY: |
379 | 0 | return symbol(((JCTypeApply) tree).clazz); |
380 | |
case JCTree.INDEXED: |
381 | 0 | return symbol(((JCArrayAccess) tree).indexed); |
382 | |
case JavafxTag.SEQUENCE_INDEXED: |
383 | 60 | return symbol(((JFXSequenceIndexed) tree).getSequence()); |
384 | |
case JavafxTag.SEQUENCE_SLICE: |
385 | 12 | return symbol(((JFXSequenceSlice) tree).getSequence()); |
386 | |
default: |
387 | 0 | return null; |
388 | |
} |
389 | |
} |
390 | |
|
391 | |
public static Symbol symbolFor(JCTree node) { |
392 | 2 | node = skipParens(node); |
393 | 2 | switch (node.getTag()) { |
394 | |
case JavafxTag.VAR_DEF: |
395 | 0 | return ((JFXVar) node).sym; |
396 | |
case JavafxTag.CLASS_DEF: |
397 | 2 | return ((JFXClassDeclaration) node).sym; |
398 | |
case JavafxTag.FUNCTION_DEF: |
399 | 0 | return ((JFXFunctionDefinition) node).sym; |
400 | |
case JavafxTag.OBJECT_LITERAL_PART: |
401 | 0 | return ((JFXObjectLiteralPart) node).sym; |
402 | |
case JavafxTag.TYPECLASS: |
403 | 0 | return symbolFor(((JFXTypeClass) node).getJCTypeTree()); |
404 | |
case JCTree.IDENT: |
405 | 0 | return ((JCIdent) node).sym; |
406 | |
case JCTree.SELECT: |
407 | 0 | return ((JCFieldAccess) node).sym; |
408 | |
case JCTree.NEWCLASS: |
409 | 0 | return ((JCNewClass) node).constructor; |
410 | |
case JCTree.APPLY: |
411 | 0 | return symbolFor(((JCMethodInvocation) node).meth); |
412 | |
case JCTree.TYPEAPPLY: |
413 | 0 | return symbolFor(((JCTypeApply) node).clazz); |
414 | |
case JCTree.TYPEPARAMETER: |
415 | 0 | return ((JCTypeParameter) node).type.tsym; |
416 | |
case JCTree.TOPLEVEL: |
417 | 0 | return ((JCCompilationUnit) node).packge; |
418 | |
|
419 | |
default: |
420 | 0 | return TreeInfo.symbolFor(node); |
421 | |
} |
422 | |
} |
423 | |
|
424 | |
|
425 | |
|
426 | |
|
427 | |
|
428 | |
|
429 | |
public static int getStartPos(JCTree tree) { |
430 | 176779 | if (tree == null) |
431 | 0 | return Position.NOPOS; |
432 | |
|
433 | 176779 | return TreeInfo.getStartPos(tree); |
434 | |
} |
435 | |
|
436 | |
|
437 | |
|
438 | |
public static int getEndPos(JCTree tree, Map<JCTree, Integer> endPositions) { |
439 | 5 | if (tree == null) |
440 | 0 | return Position.NOPOS; |
441 | |
|
442 | 5 | if (endPositions == null) { |
443 | |
|
444 | 0 | return tree instanceof JFXBlockExpression ? |
445 | |
((JFXBlockExpression)tree).endpos : TreeInfo.endPos(tree); |
446 | |
} |
447 | |
|
448 | 5 | Integer mapPos = endPositions.get(tree); |
449 | 5 | if (mapPos != null) |
450 | 5 | return mapPos; |
451 | |
|
452 | 0 | switch(tree.getTag()) { |
453 | |
case(JavafxTag.INIT_DEF): |
454 | 0 | return getEndPos((JCTree) ((JFXInitDefinition) tree).getBody(), endPositions); |
455 | |
case(JavafxTag.POSTINIT_DEF): |
456 | 0 | return getEndPos((JCTree) ((JFXPostInitDefinition) tree).getBody(), endPositions); |
457 | |
case(JavafxTag.OVERRIDE_ATTRIBUTE_DEF): { |
458 | 0 | JFXOverrideAttribute t = (JFXOverrideAttribute)tree; |
459 | 0 | if (t.getOnReplace() != null) |
460 | 0 | return getEndPos(t.getOnReplace(), endPositions); |
461 | 0 | return getEndPos(t.getInitializer(), endPositions); |
462 | |
} |
463 | |
case(JavafxTag.ON_REPLACE): |
464 | 0 | return getEndPos(((JFXOnReplace) tree).getBody(), endPositions); |
465 | |
case(JavafxTag.OBJECT_LITERAL_PART): |
466 | 0 | return getEndPos(((JFXObjectLiteralPart) tree).getExpression(), endPositions); |
467 | |
case(JavafxTag.STRING_EXPRESSION): |
468 | 0 | return tree.pos + ((JFXStringExpression) tree).translationKey.length(); |
469 | |
case(JavafxTag.BIND_EXPRESSION): |
470 | 0 | return getEndPos(((JFXBindExpression) tree).getExpression(), endPositions); |
471 | |
case(JavafxTag.FOR_EXPRESSION): |
472 | 0 | return getEndPos(((JFXForExpression) tree).getBodyExpression(), endPositions); |
473 | |
case(JavafxTag.FOR_EXPRESSION_IN_CLAUSE): |
474 | 0 | return getEndPos(((JFXForExpressionInClause) tree).getWhereExpression(), endPositions); |
475 | |
case(JavafxTag.TYPECLASS): |
476 | 0 | return getEndPos(((JFXTypeClass) tree).getClassName(), endPositions); |
477 | |
case(JavafxTag.TIME_LITERAL): |
478 | 0 | return tree.pos + tree.toString().length(); |
479 | |
} |
480 | 0 | return TreeInfo.getStartPos(tree); |
481 | |
} |
482 | |
} |