Coverage Report - com.sun.tools.javafx.tree.JavafxTreeInfo
 
Classes in this File Line Coverage Branch Coverage Complexity
JavafxTreeInfo
33%
51/153
4%
9/249
0
JavafxTreeInfo$1
100%
2/2
N/A
0
JavafxTreeInfo$1DeclScanner
0%
0/23
0%
0/16
0
JavafxTreeInfo$1PathFinder
0%
0/9
0%
0/4
0
JavafxTreeInfo$1Result
0%
0/3
N/A
0
JavafxTreeInfo$2
0%
0/5
N/A
0
 
 1  
 /*
 2  
  * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
 3  
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 4  
  *
 5  
  * This code is free software; you can redistribute it and/or modify it
 6  
  * under the terms of the GNU General Public License version 2 only, as
 7  
  * published by the Free Software Foundation.  Sun designates this
 8  
  * particular file as subject to the "Classpath" exception as provided
 9  
  * by Sun in the LICENSE file that accompanied this code.
 10  
  *
 11  
  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  
  * version 2 for more details (a copy is included in the LICENSE file that
 15  
  * accompanied this code).
 16  
  *
 17  
  * You should have received a copy of the GNU General Public License version
 18  
  * 2 along with this work; if not, write to the Free Software Foundation,
 19  
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  
  *
 21  
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 22  
  * CA 95054 USA or visit www.sun.com if you need additional information or
 23  
  * have any questions.
 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  
 /** Utility class containing inspector methods for trees.
 39  
  *
 40  
  *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
 41  
  *  you write code that depends on this, you do so at your own risk.
 42  
  *  This code and its internal interfaces are subject to change or
 43  
  *  deletion without notice.</b>
 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  
     /** A DiagnosticPosition with the preferred position set to the 
 92  
      *  end position of given tree, if it is a block with
 93  
      *  defined endpos.
 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  
     /** Find the declaration for a symbol, where
 113  
      *  that symbol is defined somewhere in the given tree. */
 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  
     /** Operator precedences values.
 187  
      */
 188  
     public static final int
 189  
         notExpression = -1,   // not an expression
 190  
         noPrec = 0,           // no enclosing expression
 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  
     /** Map operators to their precedence levels.
 205  
      */
 206  
     public static int opPrec(int op) {
 207  0
         switch(op) {
 208  
         case JCTree.ASSIGN: // Java distinguished, JavaFX doesn't -- Java-style
 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  
         // Postfix expressions
 257  
         case JCTree.POSTINC:           // _ ++
 258  0
             return Tree.Kind.POSTFIX_INCREMENT;
 259  
         case JCTree.POSTDEC:           // _ --
 260  0
             return Tree.Kind.POSTFIX_DECREMENT;
 261  
 
 262  
         // Unary operators
 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  
         // Binary operators
 277  
 
 278  
         // Multiplicative operators
 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  
         // Additive operators
 287  
         case JCTree.PLUS:              // +
 288  0
             return Tree.Kind.PLUS;
 289  
         case JCTree.MINUS:             // -
 290  0
             return Tree.Kind.MINUS;
 291  
 
 292  
         // Shift operators
 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  
         // Relational operators
 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  
         // Equality operators
 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  
         // Bitwise and logical operators
 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  
         // Conditional operators
 325  
         case JCTree.AND:               // &&
 326  0
             return Tree.Kind.CONDITIONAL_AND;
 327  
         case JCTree.OR:                // ||
 328  0
             return Tree.Kind.CONDITIONAL_OR;
 329  
 
 330  
         // Assignment operators
 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  
         // Null check (implementation detail), for example, __.getClass()
 355  
         case JCTree.NULLCHK:
 356  0
             return Tree.Kind.OTHER;
 357  
 
 358  
         // JavaFX tags which are used in javac trees
 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  
     /** If this tree is an identifier or a field, return its symbol,
 369  
      *  otherwise return null.
 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  
     /** Get the start position for a tree node.  The start position is
 425  
      * defined to be the position of the first character of the first
 426  
      * token of the node's source text.
 427  
      * @param tree  The tree node
 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  
     /** The end position of given tree, given  a table of end positions generated by the parser
 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  
             // fall back on limited info in the tree
 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  
 }