langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java
author mcimadamore
Wed, 17 Oct 2012 16:43:26 +0100
changeset 14267 6321fbe0cf50
parent 14062 b7439971a094
child 14359 d4099818ab70
permissions -rw-r--r--
7192245: Add parser support for default methods Summary: Add support for 'default' keyword in modifier position Reviewed-by: jjg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
/*
12080
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
     2
 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    23
 * questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
06bc494ca11e Initial load
duke
parents:
diff changeset
    26
package com.sun.tools.javac.tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
13077
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
    28
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    29
import com.sun.source.tree.Tree;
13077
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
    30
import com.sun.tools.javac.code.*;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    31
import com.sun.tools.javac.comp.AttrContext;
06bc494ca11e Initial load
duke
parents:
diff changeset
    32
import com.sun.tools.javac.comp.Env;
13077
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
    33
import com.sun.tools.javac.tree.JCTree.*;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    34
import com.sun.tools.javac.util.*;
06bc494ca11e Initial load
duke
parents:
diff changeset
    35
import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
06bc494ca11e Initial load
duke
parents:
diff changeset
    36
import static com.sun.tools.javac.code.Flags.*;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    37
import static com.sun.tools.javac.tree.JCTree.Tag.*;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    38
import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    39
import static com.sun.tools.javac.tree.JCTree.Tag.SYNCHRONIZED;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    40
06bc494ca11e Initial load
duke
parents:
diff changeset
    41
/** Utility class containing inspector methods for trees.
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
 *
5847
1908176fd6e3 6944312: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5520
diff changeset
    43
 *  <p><b>This is NOT part of any supported API.
1908176fd6e3 6944312: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5520
diff changeset
    44
 *  If you write code that depends on this, you do so at your own risk.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    45
 *  This code and its internal interfaces are subject to change or
06bc494ca11e Initial load
duke
parents:
diff changeset
    46
 *  deletion without notice.</b>
06bc494ca11e Initial load
duke
parents:
diff changeset
    47
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    48
public class TreeInfo {
06bc494ca11e Initial load
duke
parents:
diff changeset
    49
    protected static final Context.Key<TreeInfo> treeInfoKey =
06bc494ca11e Initial load
duke
parents:
diff changeset
    50
        new Context.Key<TreeInfo>();
06bc494ca11e Initial load
duke
parents:
diff changeset
    51
06bc494ca11e Initial load
duke
parents:
diff changeset
    52
    public static TreeInfo instance(Context context) {
06bc494ca11e Initial load
duke
parents:
diff changeset
    53
        TreeInfo instance = context.get(treeInfoKey);
06bc494ca11e Initial load
duke
parents:
diff changeset
    54
        if (instance == null)
06bc494ca11e Initial load
duke
parents:
diff changeset
    55
            instance = new TreeInfo(context);
06bc494ca11e Initial load
duke
parents:
diff changeset
    56
        return instance;
06bc494ca11e Initial load
duke
parents:
diff changeset
    57
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
    58
06bc494ca11e Initial load
duke
parents:
diff changeset
    59
    /** The names of all operators.
06bc494ca11e Initial load
duke
parents:
diff changeset
    60
     */
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    61
    private Name[] opname = new Name[Tag.getNumberOfOperators()];
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    62
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    63
    private void setOpname(Tag tag, String name, Names names) {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    64
         setOpname(tag, names.fromString(name));
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    65
     }
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    66
     private void setOpname(Tag tag, Name name) {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    67
         opname[tag.operatorIndex()] = name;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    68
     }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    69
06bc494ca11e Initial load
duke
parents:
diff changeset
    70
    private TreeInfo(Context context) {
06bc494ca11e Initial load
duke
parents:
diff changeset
    71
        context.put(treeInfoKey, this);
06bc494ca11e Initial load
duke
parents:
diff changeset
    72
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
    73
        Names names = Names.instance(context);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    74
        setOpname(POS, "+", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    75
        setOpname(NEG, names.hyphen);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    76
        setOpname(NOT, "!", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    77
        setOpname(COMPL, "~", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    78
        setOpname(PREINC, "++", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    79
        setOpname(PREDEC, "--", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    80
        setOpname(POSTINC, "++", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    81
        setOpname(POSTDEC, "--", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    82
        setOpname(NULLCHK, "<*nullchk*>", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    83
        setOpname(OR, "||", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    84
        setOpname(AND, "&&", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    85
        setOpname(EQ, "==", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    86
        setOpname(NE, "!=", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    87
        setOpname(LT, "<", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    88
        setOpname(GT, ">", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    89
        setOpname(LE, "<=", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    90
        setOpname(GE, ">=", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    91
        setOpname(BITOR, "|", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    92
        setOpname(BITXOR, "^", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    93
        setOpname(BITAND, "&", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    94
        setOpname(SL, "<<", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    95
        setOpname(SR, ">>", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    96
        setOpname(USR, ">>>", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    97
        setOpname(PLUS, "+", names);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    98
        setOpname(MINUS, names.hyphen);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
    99
        setOpname(MUL, names.asterisk);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   100
        setOpname(DIV, names.slash);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   101
        setOpname(MOD, "%", names);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
12080
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   104
    public static List<JCExpression> args(JCTree t) {
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   105
        switch (t.getTag()) {
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   106
            case APPLY:
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   107
                return ((JCMethodInvocation)t).args;
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   108
            case NEWCLASS:
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   109
                return ((JCNewClass)t).args;
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   110
            default:
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   111
                return null;
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   112
        }
23101f54df44 7144506: Attr.checkMethod should be called after inference variables have been fixed
mcimadamore
parents: 11142
diff changeset
   113
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   114
06bc494ca11e Initial load
duke
parents:
diff changeset
   115
    /** Return name of operator with given tree tag.
06bc494ca11e Initial load
duke
parents:
diff changeset
   116
     */
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   117
    public Name operatorName(JCTree.Tag tag) {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   118
        return opname[tag.operatorIndex()];
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   119
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   120
06bc494ca11e Initial load
duke
parents:
diff changeset
   121
    /** Is tree a constructor declaration?
06bc494ca11e Initial load
duke
parents:
diff changeset
   122
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   123
    public static boolean isConstructor(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   124
        if (tree.hasTag(METHODDEF)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   125
            Name name = ((JCMethodDecl) tree).name;
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   126
            return name == name.table.names.init;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   127
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   129
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   130
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   131
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
    /** Is there a constructor declaration in the given list of trees?
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
    public static boolean hasConstructors(List<JCTree> trees) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
        for (List<JCTree> l = trees; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
            if (isConstructor(l.head)) return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
5492
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
   140
    public static boolean isMultiCatch(JCCatch catchClause) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   141
        return catchClause.param.vartype.hasTag(TYPEUNION);
5492
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
   142
    }
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
   143
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   144
    /** Is statement an initializer for a synthetic field?
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   146
    public static boolean isSyntheticInit(JCTree stat) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   147
        if (stat.hasTag(EXEC)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
            JCExpressionStatement exec = (JCExpressionStatement)stat;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   149
            if (exec.expr.hasTag(ASSIGN)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
                JCAssign assign = (JCAssign)exec.expr;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   151
                if (assign.lhs.hasTag(SELECT)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
                    JCFieldAccess select = (JCFieldAccess)assign.lhs;
06bc494ca11e Initial load
duke
parents:
diff changeset
   153
                    if (select.sym != null &&
06bc494ca11e Initial load
duke
parents:
diff changeset
   154
                        (select.sym.flags() & SYNTHETIC) != 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   155
                        Name selected = name(select.selected);
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   156
                        if (selected != null && selected == selected.table.names._this)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   157
                            return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
                    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
    /** If the expression is a method call, return the method name, null
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
     *  otherwise. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
    public static Name calledMethodName(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   168
        if (tree.hasTag(EXEC)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
            JCExpressionStatement exec = (JCExpressionStatement)tree;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   170
            if (exec.expr.hasTag(APPLY)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   171
                Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
06bc494ca11e Initial load
duke
parents:
diff changeset
   172
                return mname;
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   174
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   177
06bc494ca11e Initial load
duke
parents:
diff changeset
   178
    /** Is this a call to this or super?
06bc494ca11e Initial load
duke
parents:
diff changeset
   179
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   180
    public static boolean isSelfCall(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   181
        Name name = calledMethodName(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   182
        if (name != null) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   183
            Names names = name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   184
            return name==names._this || name==names._super;
06bc494ca11e Initial load
duke
parents:
diff changeset
   185
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   186
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   187
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   188
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
    /** Is this a call to super?
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
    public static boolean isSuperCall(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
        Name name = calledMethodName(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
        if (name != null) {
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   195
            Names names = name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
            return name==names._super;
06bc494ca11e Initial load
duke
parents:
diff changeset
   197
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   199
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
    /** Is this a constructor whose first (non-synthetic) statement is not
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
     *  of the form this(...)?
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
    public static boolean isInitialConstructor(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
        JCMethodInvocation app = firstConstructorCall(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
        if (app == null) return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   208
        Name meth = name(app.meth);
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   209
        return meth == null || meth != meth.table.names._this;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
    /** Return the first call in a constructor definition. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   213
    public static JCMethodInvocation firstConstructorCall(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   214
        if (!tree.hasTag(METHODDEF)) return null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   215
        JCMethodDecl md = (JCMethodDecl) tree;
1260
a772ba9ba43d 6574134: Allow for alternative implementation of Name Table with garbage collection of name bytes
jjg
parents: 1206
diff changeset
   216
        Names names = md.name.table.names;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   217
        if (md.name != names.init) return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   218
        if (md.body == null) return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   219
        List<JCStatement> stats = md.body.stats;
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
        // Synthetic initializations can appear before the super call.
06bc494ca11e Initial load
duke
parents:
diff changeset
   221
        while (stats.nonEmpty() && isSyntheticInit(stats.head))
06bc494ca11e Initial load
duke
parents:
diff changeset
   222
            stats = stats.tail;
06bc494ca11e Initial load
duke
parents:
diff changeset
   223
        if (stats.isEmpty()) return null;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   224
        if (!stats.head.hasTag(EXEC)) return null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   225
        JCExpressionStatement exec = (JCExpressionStatement) stats.head;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   226
        if (!exec.expr.hasTag(APPLY)) return null;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   227
        return (JCMethodInvocation)exec.expr;
06bc494ca11e Initial load
duke
parents:
diff changeset
   228
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   229
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   230
    /** Return true if a tree represents a diamond new expr. */
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   231
    public static boolean isDiamond(JCTree tree) {
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   232
        switch(tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   233
            case TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   234
            case NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   235
            default: return false;
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   236
        }
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   237
    }
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   238
12916
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   239
    public static boolean isEnumInit(JCTree tree) {
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   240
        switch (tree.getTag()) {
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   241
            case VARDEF:
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   242
                return (((JCVariableDecl)tree).mods.flags & ENUM) != 0;
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   243
            default:
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   244
                return false;
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   245
        }
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   246
    }
021c069e8e27 7160084: javac fails to compile an apparently valid class/interface combination
mcimadamore
parents: 12080
diff changeset
   247
14057
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   248
    /** Return true if a a tree corresponds to a poly expression. */
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   249
    public static boolean isPoly(JCTree tree, JCTree origin) {
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   250
        switch (tree.getTag()) {
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   251
            case APPLY:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   252
            case NEWCLASS:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   253
            case CONDEXPR:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   254
                return !origin.hasTag(TYPECAST);
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   255
            case LAMBDA:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   256
            case REFERENCE:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   257
                return true;
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   258
            case PARENS:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   259
                return isPoly(((JCParens)tree).expr, origin);
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   260
            default:
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   261
                return false;
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   262
        }
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   263
    }
b4b0377b8dba 7177387: Add target-typing support in method context
mcimadamore
parents: 13442
diff changeset
   264
14058
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   265
    public static boolean isExplicitLambda(JCLambda lambda) {
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   266
        return lambda.params.isEmpty() ||
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   267
                lambda.params.head.vartype != null;
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   268
    }
11142
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   269
    /**
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   270
     * Return true if the AST corresponds to a static select of the kind A.B
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   271
     */
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   272
    public static boolean isStaticSelector(JCTree base, Names names) {
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   273
        if (base == null)
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   274
            return false;
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   275
        switch (base.getTag()) {
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   276
            case IDENT:
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   277
                JCIdent id = (JCIdent)base;
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   278
                return id.name != names._this &&
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   279
                        id.name != names._super &&
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   280
                        isStaticSym(base);
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   281
            case SELECT:
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   282
                return isStaticSym(base) &&
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   283
                    isStaticSelector(((JCFieldAccess)base).selected, names);
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   284
            case TYPEAPPLY:
14062
b7439971a094 7177386: Add attribution support for method references
mcimadamore
parents: 14058
diff changeset
   285
            case TYPEARRAY:
11142
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   286
                return true;
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   287
            default:
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   288
                return false;
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   289
        }
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   290
    }
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   291
    //where
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   292
        private static boolean isStaticSym(JCTree tree) {
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   293
            Symbol sym = symbol(tree);
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   294
            return (sym.kind == Kinds.TYP ||
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   295
                    sym.kind == Kinds.PCK);
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   296
        }
45d0ec1e7463 7115049: Add AST node for method references
mcimadamore
parents: 11055
diff changeset
   297
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   298
    /** Return true if a tree represents the null literal. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   299
    public static boolean isNull(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   300
        if (!tree.hasTag(LITERAL))
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   301
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   302
        JCLiteral lit = (JCLiteral) tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   303
        return (lit.typetag == TypeTags.BOT);
06bc494ca11e Initial load
duke
parents:
diff changeset
   304
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   305
13077
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   306
    public static String getCommentText(Env<?> env, JCTree tree) {
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   307
        DocCommentTable docComments = (tree.hasTag(JCTree.Tag.TOPLEVEL))
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   308
                ? ((JCCompilationUnit) tree).docComments
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   309
                : env.toplevel.docComments;
13078
11d5e1c88864 7178297: provide mapping from doc comment position to source file position
jjg
parents: 13077
diff changeset
   310
        return (docComments == null) ? null : docComments.getCommentText(tree);
13077
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   311
    }
16fb753bb5dc 7174143: encapsulate doc comment table
jjg
parents: 12916
diff changeset
   312
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   313
    /** The position of the first statement in a block, or the position of
06bc494ca11e Initial load
duke
parents:
diff changeset
   314
     *  the block itself if it is empty.
06bc494ca11e Initial load
duke
parents:
diff changeset
   315
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   316
    public static int firstStatPos(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   317
        if (tree.hasTag(BLOCK) && ((JCBlock) tree).stats.nonEmpty())
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   318
            return ((JCBlock) tree).stats.head.pos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   319
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
            return tree.pos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   321
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   322
06bc494ca11e Initial load
duke
parents:
diff changeset
   323
    /** The end position of given tree, if it is a block with
06bc494ca11e Initial load
duke
parents:
diff changeset
   324
     *  defined endpos.
06bc494ca11e Initial load
duke
parents:
diff changeset
   325
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   326
    public static int endPos(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   327
        if (tree.hasTag(BLOCK) && ((JCBlock) tree).endpos != Position.NOPOS)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   328
            return ((JCBlock) tree).endpos;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   329
        else if (tree.hasTag(SYNCHRONIZED))
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   330
            return endPos(((JCSynchronized) tree).body);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   331
        else if (tree.hasTag(TRY)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
            JCTry t = (JCTry) tree;
13442
41b5b4736385 7178324: Crash when compiling for(i : x) try(AutoCloseable x = ...) {}
sundar
parents: 13078
diff changeset
   333
            return endPos((t.finalizer != null) ? t.finalizer
41b5b4736385 7178324: Crash when compiling for(i : x) try(AutoCloseable x = ...) {}
sundar
parents: 13078
diff changeset
   334
                          : (t.catchers.nonEmpty() ? t.catchers.last().body : t.body));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   335
        } else
06bc494ca11e Initial load
duke
parents:
diff changeset
   336
            return tree.pos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   337
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   338
06bc494ca11e Initial load
duke
parents:
diff changeset
   339
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
    /** Get the start position for a tree node.  The start position is
06bc494ca11e Initial load
duke
parents:
diff changeset
   341
     * defined to be the position of the first character of the first
06bc494ca11e Initial load
duke
parents:
diff changeset
   342
     * token of the node's source text.
06bc494ca11e Initial load
duke
parents:
diff changeset
   343
     * @param tree  The tree node
06bc494ca11e Initial load
duke
parents:
diff changeset
   344
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   345
    public static int getStartPos(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   346
        if (tree == null)
06bc494ca11e Initial load
duke
parents:
diff changeset
   347
            return Position.NOPOS;
06bc494ca11e Initial load
duke
parents:
diff changeset
   348
06bc494ca11e Initial load
duke
parents:
diff changeset
   349
        switch(tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   350
            case APPLY:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   351
                return getStartPos(((JCMethodInvocation) tree).meth);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   352
            case ASSIGN:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   353
                return getStartPos(((JCAssign) tree).lhs);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   354
            case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   355
            case SL_ASG: case SR_ASG: case USR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   356
            case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   357
            case DIV_ASG: case MOD_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   358
                return getStartPos(((JCAssignOp) tree).lhs);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   359
            case OR: case AND: case BITOR:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   360
            case BITXOR: case BITAND: case EQ:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   361
            case NE: case LT: case GT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   362
            case LE: case GE: case SL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   363
            case SR: case USR: case PLUS:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   364
            case MINUS: case MUL: case DIV:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   365
            case MOD:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   366
                return getStartPos(((JCBinary) tree).lhs);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   367
            case CLASSDEF: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   368
                JCClassDecl node = (JCClassDecl)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   369
                if (node.mods.pos != Position.NOPOS)
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   370
                    return node.mods.pos;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   371
                break;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   372
            }
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   373
            case CONDEXPR:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   374
                return getStartPos(((JCConditional) tree).cond);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   375
            case EXEC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   376
                return getStartPos(((JCExpressionStatement) tree).expr);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   377
            case INDEXED:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   378
                return getStartPos(((JCArrayAccess) tree).indexed);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   379
            case METHODDEF: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   380
                JCMethodDecl node = (JCMethodDecl)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   381
                if (node.mods.pos != Position.NOPOS)
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   382
                    return node.mods.pos;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   383
                if (node.typarams.nonEmpty()) // List.nil() used for no typarams
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   384
                    return getStartPos(node.typarams.head);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   385
                return node.restype == null ? node.pos : getStartPos(node.restype);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   386
            }
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   387
            case SELECT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   388
                return getStartPos(((JCFieldAccess) tree).selected);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   389
            case TYPEAPPLY:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   390
                return getStartPos(((JCTypeApply) tree).clazz);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   391
            case TYPEARRAY:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   392
                return getStartPos(((JCArrayTypeTree) tree).elemtype);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   393
            case TYPETEST:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   394
                return getStartPos(((JCInstanceOf) tree).expr);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   395
            case POSTINC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   396
            case POSTDEC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   397
                return getStartPos(((JCUnary) tree).arg);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   398
            case NEWCLASS: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   399
                JCNewClass node = (JCNewClass)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   400
                if (node.encl != null)
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   401
                    return getStartPos(node.encl);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   402
                break;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   403
            }
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   404
            case VARDEF: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   405
                JCVariableDecl node = (JCVariableDecl)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   406
                if (node.mods.pos != Position.NOPOS) {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   407
                    return node.mods.pos;
14058
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   408
                } else if (node.vartype == null) {
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   409
                    //if there's no type (partially typed lambda parameter)
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   410
                    //simply return node position
c7ec7facdd20 7177385: Add attribution support for lambda expressions
mcimadamore
parents: 14057
diff changeset
   411
                    return node.pos;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   412
                } else {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   413
                    return getStartPos(node.vartype);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   414
                }
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   415
            }
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   416
            case ERRONEOUS: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   417
                JCErroneous node = (JCErroneous)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   418
                if (node.errs != null && node.errs.nonEmpty())
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   419
                    return getStartPos(node.errs.head);
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   420
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
        return tree.pos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
    /** The end position of given tree, given  a table of end positions generated by the parser
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
     */
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   427
    public static int getEndPos(JCTree tree, EndPosTable endPosTable) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
        if (tree == null)
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
            return Position.NOPOS;
06bc494ca11e Initial load
duke
parents:
diff changeset
   430
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   431
        if (endPosTable == null) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   432
            // fall back on limited info in the tree
06bc494ca11e Initial load
duke
parents:
diff changeset
   433
            return endPos(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   434
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   435
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   436
        int mapPos = endPosTable.getEndPos(tree);
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   437
        if (mapPos != Position.NOPOS)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   438
            return mapPos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
        switch(tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   441
            case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   442
            case SL_ASG: case SR_ASG: case USR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   443
            case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   444
            case DIV_ASG: case MOD_ASG:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   445
                return getEndPos(((JCAssignOp) tree).rhs, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   446
            case OR: case AND: case BITOR:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   447
            case BITXOR: case BITAND: case EQ:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   448
            case NE: case LT: case GT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   449
            case LE: case GE: case SL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   450
            case SR: case USR: case PLUS:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   451
            case MINUS: case MUL: case DIV:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   452
            case MOD:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   453
                return getEndPos(((JCBinary) tree).rhs, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   454
            case CASE:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   455
                return getEndPos(((JCCase) tree).stats.last(), endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   456
            case CATCH:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   457
                return getEndPos(((JCCatch) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   458
            case CONDEXPR:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   459
                return getEndPos(((JCConditional) tree).falsepart, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   460
            case FORLOOP:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   461
                return getEndPos(((JCForLoop) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   462
            case FOREACHLOOP:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   463
                return getEndPos(((JCEnhancedForLoop) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   464
            case IF: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   465
                JCIf node = (JCIf)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   466
                if (node.elsepart == null) {
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   467
                    return getEndPos(node.thenpart, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   468
                } else {
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   469
                    return getEndPos(node.elsepart, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   470
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   471
            }
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   472
            case LABELLED:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   473
                return getEndPos(((JCLabeledStatement) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   474
            case MODIFIERS:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   475
                return getEndPos(((JCModifiers) tree).annotations.last(), endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   476
            case SYNCHRONIZED:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   477
                return getEndPos(((JCSynchronized) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   478
            case TOPLEVEL:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   479
                return getEndPos(((JCCompilationUnit) tree).defs.last(), endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   480
            case TRY: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   481
                JCTry node = (JCTry)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   482
                if (node.finalizer != null) {
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   483
                    return getEndPos(node.finalizer, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   484
                } else if (!node.catchers.isEmpty()) {
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   485
                    return getEndPos(node.catchers.last(), endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   486
                } else {
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   487
                    return getEndPos(node.body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   488
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   489
            }
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   490
            case WILDCARD:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   491
                return getEndPos(((JCWildcard) tree).inner, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   492
            case TYPECAST:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   493
                return getEndPos(((JCTypeCast) tree).expr, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   494
            case TYPETEST:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   495
                return getEndPos(((JCInstanceOf) tree).clazz, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   496
            case POS:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   497
            case NEG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   498
            case NOT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   499
            case COMPL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   500
            case PREINC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   501
            case PREDEC:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   502
                return getEndPos(((JCUnary) tree).arg, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   503
            case WHILELOOP:
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   504
                return getEndPos(((JCWhileLoop) tree).body, endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   505
            case ERRONEOUS: {
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   506
                JCErroneous node = (JCErroneous)tree;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   507
                if (node.errs != null && node.errs.nonEmpty())
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   508
                    return getEndPos(node.errs.last(), endPosTable);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   509
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   510
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   511
        return Position.NOPOS;
06bc494ca11e Initial load
duke
parents:
diff changeset
   512
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   513
06bc494ca11e Initial load
duke
parents:
diff changeset
   514
06bc494ca11e Initial load
duke
parents:
diff changeset
   515
    /** A DiagnosticPosition with the preferred position set to the
06bc494ca11e Initial load
duke
parents:
diff changeset
   516
     *  end position of given tree, if it is a block with
06bc494ca11e Initial load
duke
parents:
diff changeset
   517
     *  defined endpos.
06bc494ca11e Initial load
duke
parents:
diff changeset
   518
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   519
    public static DiagnosticPosition diagEndPos(final JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   520
        final int endPos = TreeInfo.endPos(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
        return new DiagnosticPosition() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
            public JCTree getTree() { return tree; }
06bc494ca11e Initial load
duke
parents:
diff changeset
   523
            public int getStartPosition() { return TreeInfo.getStartPos(tree); }
06bc494ca11e Initial load
duke
parents:
diff changeset
   524
            public int getPreferredPosition() { return endPos; }
11055
ec1418effa77 7106166: (javac) re-factor EndPos parser
ksrini
parents: 10950
diff changeset
   525
            public int getEndPosition(EndPosTable endPosTable) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   526
                return TreeInfo.getEndPos(tree, endPosTable);
06bc494ca11e Initial load
duke
parents:
diff changeset
   527
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   528
        };
06bc494ca11e Initial load
duke
parents:
diff changeset
   529
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   530
06bc494ca11e Initial load
duke
parents:
diff changeset
   531
    /** The position of the finalizer of given try/synchronized statement.
06bc494ca11e Initial load
duke
parents:
diff changeset
   532
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   533
    public static int finalizerPos(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   534
        if (tree.hasTag(TRY)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   535
            JCTry t = (JCTry) tree;
8032
e1aa25ccdabb 6396503: javac should not require assertions enabled
jjg
parents: 8031
diff changeset
   536
            Assert.checkNonNull(t.finalizer);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   537
            return firstStatPos(t.finalizer);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   538
        } else if (tree.hasTag(SYNCHRONIZED)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   539
            return endPos(((JCSynchronized) tree).body);
06bc494ca11e Initial load
duke
parents:
diff changeset
   540
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   541
            throw new AssertionError();
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
    /** Find the position for reporting an error about a symbol, where
06bc494ca11e Initial load
duke
parents:
diff changeset
   546
     *  that symbol is defined somewhere in the given tree. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
    public static int positionFor(final Symbol sym, final JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
        JCTree decl = declarationFor(sym, tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   549
        return ((decl != null) ? decl : tree).pos;
06bc494ca11e Initial load
duke
parents:
diff changeset
   550
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   551
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
    /** Find the position for reporting an error about a symbol, where
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
     *  that symbol is defined somewhere in the given tree. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
    public static DiagnosticPosition diagnosticPositionFor(final Symbol sym, final JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   555
        JCTree decl = declarationFor(sym, tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   556
        return ((decl != null) ? decl : tree).pos();
06bc494ca11e Initial load
duke
parents:
diff changeset
   557
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   558
06bc494ca11e Initial load
duke
parents:
diff changeset
   559
    /** Find the declaration for a symbol, where
06bc494ca11e Initial load
duke
parents:
diff changeset
   560
     *  that symbol is defined somewhere in the given tree. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   561
    public static JCTree declarationFor(final Symbol sym, final JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
        class DeclScanner extends TreeScanner {
06bc494ca11e Initial load
duke
parents:
diff changeset
   563
            JCTree result = null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   564
            public void scan(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
                if (tree!=null && result==null)
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
                    tree.accept(this);
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
            public void visitTopLevel(JCCompilationUnit that) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
                if (that.packge == sym) result = that;
06bc494ca11e Initial load
duke
parents:
diff changeset
   570
                else super.visitTopLevel(that);
06bc494ca11e Initial load
duke
parents:
diff changeset
   571
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
            public void visitClassDef(JCClassDecl that) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
                if (that.sym == sym) result = that;
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
                else super.visitClassDef(that);
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   576
            public void visitMethodDef(JCMethodDecl that) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   577
                if (that.sym == sym) result = that;
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
                else super.visitMethodDef(that);
06bc494ca11e Initial load
duke
parents:
diff changeset
   579
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
            public void visitVarDef(JCVariableDecl that) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   581
                if (that.sym == sym) result = that;
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
                else super.visitVarDef(that);
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
            }
6586
0d40dc0c06cb 6458823: Messager messages on TypeParamterElements to not include position information.
sundar
parents: 5847
diff changeset
   584
            public void visitTypeParameter(JCTypeParameter that) {
7619
1bedd48ff024 6990209: JCK7-compiler lang/ICLS/icls006/icls00603/icls00603a.html#icls00603src test fails.
jjh
parents: 7074
diff changeset
   585
                if (that.type != null && that.type.tsym == sym) result = that;
6586
0d40dc0c06cb 6458823: Messager messages on TypeParamterElements to not include position information.
sundar
parents: 5847
diff changeset
   586
                else super.visitTypeParameter(that);
0d40dc0c06cb 6458823: Messager messages on TypeParamterElements to not include position information.
sundar
parents: 5847
diff changeset
   587
            }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   588
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   589
        DeclScanner s = new DeclScanner();
06bc494ca11e Initial load
duke
parents:
diff changeset
   590
        tree.accept(s);
06bc494ca11e Initial load
duke
parents:
diff changeset
   591
        return s.result;
06bc494ca11e Initial load
duke
parents:
diff changeset
   592
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   593
06bc494ca11e Initial load
duke
parents:
diff changeset
   594
    public static Env<AttrContext> scopeFor(JCTree node, JCCompilationUnit unit) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   595
        return scopeFor(pathFor(node, unit));
06bc494ca11e Initial load
duke
parents:
diff changeset
   596
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   597
06bc494ca11e Initial load
duke
parents:
diff changeset
   598
    public static Env<AttrContext> scopeFor(List<JCTree> path) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   599
        // TODO: not implemented yet
06bc494ca11e Initial load
duke
parents:
diff changeset
   600
        throw new UnsupportedOperationException("not implemented yet");
06bc494ca11e Initial load
duke
parents:
diff changeset
   601
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   602
06bc494ca11e Initial load
duke
parents:
diff changeset
   603
    public static List<JCTree> pathFor(final JCTree node, final JCCompilationUnit unit) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   604
        class Result extends Error {
06bc494ca11e Initial load
duke
parents:
diff changeset
   605
            static final long serialVersionUID = -5942088234594905625L;
06bc494ca11e Initial load
duke
parents:
diff changeset
   606
            List<JCTree> path;
06bc494ca11e Initial load
duke
parents:
diff changeset
   607
            Result(List<JCTree> path) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   608
                this.path = path;
06bc494ca11e Initial load
duke
parents:
diff changeset
   609
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   610
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   611
        class PathFinder extends TreeScanner {
06bc494ca11e Initial load
duke
parents:
diff changeset
   612
            List<JCTree> path = List.nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   613
            public void scan(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   614
                if (tree != null) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   615
                    path = path.prepend(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   616
                    if (tree == node)
06bc494ca11e Initial load
duke
parents:
diff changeset
   617
                        throw new Result(path);
06bc494ca11e Initial load
duke
parents:
diff changeset
   618
                    super.scan(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   619
                    path = path.tail;
06bc494ca11e Initial load
duke
parents:
diff changeset
   620
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   621
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   622
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   623
        try {
06bc494ca11e Initial load
duke
parents:
diff changeset
   624
            new PathFinder().scan(unit);
06bc494ca11e Initial load
duke
parents:
diff changeset
   625
        } catch (Result result) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   626
            return result.path;
06bc494ca11e Initial load
duke
parents:
diff changeset
   627
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   628
        return List.nil();
06bc494ca11e Initial load
duke
parents:
diff changeset
   629
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   630
06bc494ca11e Initial load
duke
parents:
diff changeset
   631
    /** Return the statement referenced by a label.
06bc494ca11e Initial load
duke
parents:
diff changeset
   632
     *  If the label refers to a loop or switch, return that switch
06bc494ca11e Initial load
duke
parents:
diff changeset
   633
     *  otherwise return the labelled statement itself
06bc494ca11e Initial load
duke
parents:
diff changeset
   634
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   635
    public static JCTree referencedStatement(JCLabeledStatement tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   636
        JCTree t = tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   637
        do t = ((JCLabeledStatement) t).body;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   638
        while (t.hasTag(LABELLED));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   639
        switch (t.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   640
        case DOLOOP: case WHILELOOP: case FORLOOP: case FOREACHLOOP: case SWITCH:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   641
            return t;
06bc494ca11e Initial load
duke
parents:
diff changeset
   642
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   643
            return tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   644
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   645
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   646
06bc494ca11e Initial load
duke
parents:
diff changeset
   647
    /** Skip parens and return the enclosed expression
06bc494ca11e Initial load
duke
parents:
diff changeset
   648
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   649
    public static JCExpression skipParens(JCExpression tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   650
        while (tree.hasTag(PARENS)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   651
            tree = ((JCParens) tree).expr;
06bc494ca11e Initial load
duke
parents:
diff changeset
   652
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   653
        return tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   654
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   655
06bc494ca11e Initial load
duke
parents:
diff changeset
   656
    /** Skip parens and return the enclosed expression
06bc494ca11e Initial load
duke
parents:
diff changeset
   657
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   658
    public static JCTree skipParens(JCTree tree) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   659
        if (tree.hasTag(PARENS))
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   660
            return skipParens((JCParens)tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   661
        else
06bc494ca11e Initial load
duke
parents:
diff changeset
   662
            return tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   663
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   664
06bc494ca11e Initial load
duke
parents:
diff changeset
   665
    /** Return the types of a list of trees.
06bc494ca11e Initial load
duke
parents:
diff changeset
   666
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   667
    public static List<Type> types(List<? extends JCTree> trees) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   668
        ListBuffer<Type> ts = new ListBuffer<Type>();
06bc494ca11e Initial load
duke
parents:
diff changeset
   669
        for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
06bc494ca11e Initial load
duke
parents:
diff changeset
   670
            ts.append(l.head.type);
06bc494ca11e Initial load
duke
parents:
diff changeset
   671
        return ts.toList();
06bc494ca11e Initial load
duke
parents:
diff changeset
   672
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   673
06bc494ca11e Initial load
duke
parents:
diff changeset
   674
    /** If this tree is an identifier or a field or a parameterized type,
06bc494ca11e Initial load
duke
parents:
diff changeset
   675
     *  return its name, otherwise return null.
06bc494ca11e Initial load
duke
parents:
diff changeset
   676
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   677
    public static Name name(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   678
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   679
        case IDENT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   680
            return ((JCIdent) tree).name;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   681
        case SELECT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   682
            return ((JCFieldAccess) tree).name;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   683
        case TYPEAPPLY:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   684
            return name(((JCTypeApply) tree).clazz);
06bc494ca11e Initial load
duke
parents:
diff changeset
   685
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   686
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   687
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   688
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   689
06bc494ca11e Initial load
duke
parents:
diff changeset
   690
    /** If this tree is a qualified identifier, its return fully qualified name,
06bc494ca11e Initial load
duke
parents:
diff changeset
   691
     *  otherwise return null.
06bc494ca11e Initial load
duke
parents:
diff changeset
   692
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   693
    public static Name fullName(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   694
        tree = skipParens(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   695
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   696
        case IDENT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   697
            return ((JCIdent) tree).name;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   698
        case SELECT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   699
            Name sname = fullName(((JCFieldAccess) tree).selected);
06bc494ca11e Initial load
duke
parents:
diff changeset
   700
            return sname == null ? null : sname.append('.', name(tree));
06bc494ca11e Initial load
duke
parents:
diff changeset
   701
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   702
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   703
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   704
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   705
06bc494ca11e Initial load
duke
parents:
diff changeset
   706
    public static Symbol symbolFor(JCTree node) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   707
        node = skipParens(node);
06bc494ca11e Initial load
duke
parents:
diff changeset
   708
        switch (node.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   709
        case CLASSDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   710
            return ((JCClassDecl) node).sym;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   711
        case METHODDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   712
            return ((JCMethodDecl) node).sym;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   713
        case VARDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   714
            return ((JCVariableDecl) node).sym;
06bc494ca11e Initial load
duke
parents:
diff changeset
   715
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   716
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   717
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   718
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   719
6590
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   720
    public static boolean isDeclaration(JCTree node) {
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   721
        node = skipParens(node);
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   722
        switch (node.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   723
        case CLASSDEF:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   724
        case METHODDEF:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   725
        case VARDEF:
6590
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   726
            return true;
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   727
        default:
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   728
            return false;
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   729
        }
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   730
    }
f745e683da2c 6930507: Symbols for anonymous and local classes made too late for use by java tree API
jjg
parents: 6586
diff changeset
   731
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   732
    /** If this tree is an identifier or a field, return its symbol,
06bc494ca11e Initial load
duke
parents:
diff changeset
   733
     *  otherwise return null.
06bc494ca11e Initial load
duke
parents:
diff changeset
   734
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   735
    public static Symbol symbol(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   736
        tree = skipParens(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   737
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   738
        case IDENT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   739
            return ((JCIdent) tree).sym;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   740
        case SELECT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   741
            return ((JCFieldAccess) tree).sym;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   742
        case TYPEAPPLY:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   743
            return symbol(((JCTypeApply) tree).clazz);
06bc494ca11e Initial load
duke
parents:
diff changeset
   744
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   745
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   746
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   747
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   748
06bc494ca11e Initial load
duke
parents:
diff changeset
   749
    /** Return true if this is a nonstatic selection. */
06bc494ca11e Initial load
duke
parents:
diff changeset
   750
    public static boolean nonstaticSelect(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   751
        tree = skipParens(tree);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   752
        if (!tree.hasTag(SELECT)) return false;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   753
        JCFieldAccess s = (JCFieldAccess) tree;
06bc494ca11e Initial load
duke
parents:
diff changeset
   754
        Symbol e = symbol(s.selected);
06bc494ca11e Initial load
duke
parents:
diff changeset
   755
        return e == null || (e.kind != Kinds.PCK && e.kind != Kinds.TYP);
06bc494ca11e Initial load
duke
parents:
diff changeset
   756
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   757
06bc494ca11e Initial load
duke
parents:
diff changeset
   758
    /** If this tree is an identifier or a field, set its symbol, otherwise skip.
06bc494ca11e Initial load
duke
parents:
diff changeset
   759
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   760
    public static void setSymbol(JCTree tree, Symbol sym) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   761
        tree = skipParens(tree);
06bc494ca11e Initial load
duke
parents:
diff changeset
   762
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   763
        case IDENT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   764
            ((JCIdent) tree).sym = sym; break;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   765
        case SELECT:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   766
            ((JCFieldAccess) tree).sym = sym; break;
06bc494ca11e Initial load
duke
parents:
diff changeset
   767
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   768
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   769
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   770
06bc494ca11e Initial load
duke
parents:
diff changeset
   771
    /** If this tree is a declaration or a block, return its flags field,
06bc494ca11e Initial load
duke
parents:
diff changeset
   772
     *  otherwise return 0.
06bc494ca11e Initial load
duke
parents:
diff changeset
   773
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   774
    public static long flags(JCTree tree) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   775
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   776
        case VARDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   777
            return ((JCVariableDecl) tree).mods.flags;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   778
        case METHODDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   779
            return ((JCMethodDecl) tree).mods.flags;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   780
        case CLASSDEF:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   781
            return ((JCClassDecl) tree).mods.flags;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   782
        case BLOCK:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   783
            return ((JCBlock) tree).flags;
06bc494ca11e Initial load
duke
parents:
diff changeset
   784
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   785
            return 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   786
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   787
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   788
06bc494ca11e Initial load
duke
parents:
diff changeset
   789
    /** Return first (smallest) flag in `flags':
06bc494ca11e Initial load
duke
parents:
diff changeset
   790
     *  pre: flags != 0
06bc494ca11e Initial load
duke
parents:
diff changeset
   791
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   792
    public static long firstFlag(long flags) {
14267
6321fbe0cf50 7192245: Add parser support for default methods
mcimadamore
parents: 14062
diff changeset
   793
        long flag = 1;
6321fbe0cf50 7192245: Add parser support for default methods
mcimadamore
parents: 14062
diff changeset
   794
        while ((flag & flags & ExtendedStandardFlags) == 0)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   795
            flag = flag << 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   796
        return flag;
06bc494ca11e Initial load
duke
parents:
diff changeset
   797
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   798
06bc494ca11e Initial load
duke
parents:
diff changeset
   799
    /** Return flags as a string, separated by " ".
06bc494ca11e Initial load
duke
parents:
diff changeset
   800
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   801
    public static String flagNames(long flags) {
14267
6321fbe0cf50 7192245: Add parser support for default methods
mcimadamore
parents: 14062
diff changeset
   802
        return Flags.toString(flags & ExtendedStandardFlags).trim();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   803
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   804
06bc494ca11e Initial load
duke
parents:
diff changeset
   805
    /** Operator precedences values.
06bc494ca11e Initial load
duke
parents:
diff changeset
   806
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   807
    public static final int
06bc494ca11e Initial load
duke
parents:
diff changeset
   808
        notExpression = -1,   // not an expression
06bc494ca11e Initial load
duke
parents:
diff changeset
   809
        noPrec = 0,           // no enclosing expression
06bc494ca11e Initial load
duke
parents:
diff changeset
   810
        assignPrec = 1,
06bc494ca11e Initial load
duke
parents:
diff changeset
   811
        assignopPrec = 2,
06bc494ca11e Initial load
duke
parents:
diff changeset
   812
        condPrec = 3,
06bc494ca11e Initial load
duke
parents:
diff changeset
   813
        orPrec = 4,
06bc494ca11e Initial load
duke
parents:
diff changeset
   814
        andPrec = 5,
06bc494ca11e Initial load
duke
parents:
diff changeset
   815
        bitorPrec = 6,
06bc494ca11e Initial load
duke
parents:
diff changeset
   816
        bitxorPrec = 7,
06bc494ca11e Initial load
duke
parents:
diff changeset
   817
        bitandPrec = 8,
06bc494ca11e Initial load
duke
parents:
diff changeset
   818
        eqPrec = 9,
06bc494ca11e Initial load
duke
parents:
diff changeset
   819
        ordPrec = 10,
06bc494ca11e Initial load
duke
parents:
diff changeset
   820
        shiftPrec = 11,
06bc494ca11e Initial load
duke
parents:
diff changeset
   821
        addPrec = 12,
06bc494ca11e Initial load
duke
parents:
diff changeset
   822
        mulPrec = 13,
06bc494ca11e Initial load
duke
parents:
diff changeset
   823
        prefixPrec = 14,
06bc494ca11e Initial load
duke
parents:
diff changeset
   824
        postfixPrec = 15,
06bc494ca11e Initial load
duke
parents:
diff changeset
   825
        precCount = 16;
06bc494ca11e Initial load
duke
parents:
diff changeset
   826
06bc494ca11e Initial load
duke
parents:
diff changeset
   827
06bc494ca11e Initial load
duke
parents:
diff changeset
   828
    /** Map operators to their precedence levels.
06bc494ca11e Initial load
duke
parents:
diff changeset
   829
     */
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   830
    public static int opPrec(JCTree.Tag op) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   831
        switch(op) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   832
        case POS:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   833
        case NEG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   834
        case NOT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   835
        case COMPL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   836
        case PREINC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   837
        case PREDEC: return prefixPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   838
        case POSTINC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   839
        case POSTDEC:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   840
        case NULLCHK: return postfixPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   841
        case ASSIGN: return assignPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   842
        case BITOR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   843
        case BITXOR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   844
        case BITAND_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   845
        case SL_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   846
        case SR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   847
        case USR_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   848
        case PLUS_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   849
        case MINUS_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   850
        case MUL_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   851
        case DIV_ASG:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   852
        case MOD_ASG: return assignopPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   853
        case OR: return orPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   854
        case AND: return andPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   855
        case EQ:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   856
        case NE: return eqPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   857
        case LT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   858
        case GT:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   859
        case LE:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   860
        case GE: return ordPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   861
        case BITOR: return bitorPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   862
        case BITXOR: return bitxorPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   863
        case BITAND: return bitandPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   864
        case SL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   865
        case SR:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   866
        case USR: return shiftPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   867
        case PLUS:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   868
        case MINUS: return addPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   869
        case MUL:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   870
        case DIV:
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   871
        case MOD: return mulPrec;
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   872
        case TYPETEST: return ordPrec;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   873
        default: throw new AssertionError();
06bc494ca11e Initial load
duke
parents:
diff changeset
   874
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   875
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   876
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   877
    static Tree.Kind tagToKind(JCTree.Tag tag) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   878
        switch (tag) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   879
        // Postfix expressions
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   880
        case POSTINC:           // _ ++
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   881
            return Tree.Kind.POSTFIX_INCREMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   882
        case POSTDEC:           // _ --
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   883
            return Tree.Kind.POSTFIX_DECREMENT;
06bc494ca11e Initial load
duke
parents:
diff changeset
   884
06bc494ca11e Initial load
duke
parents:
diff changeset
   885
        // Unary operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   886
        case PREINC:            // ++ _
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   887
            return Tree.Kind.PREFIX_INCREMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   888
        case PREDEC:            // -- _
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
            return Tree.Kind.PREFIX_DECREMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   890
        case POS:               // +
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   891
            return Tree.Kind.UNARY_PLUS;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   892
        case NEG:               // -
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
            return Tree.Kind.UNARY_MINUS;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   894
        case COMPL:             // ~
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
            return Tree.Kind.BITWISE_COMPLEMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   896
        case NOT:               // !
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
            return Tree.Kind.LOGICAL_COMPLEMENT;
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
        // Binary operators
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
        // Multiplicative operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   902
        case MUL:               // *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
            return Tree.Kind.MULTIPLY;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   904
        case DIV:               // /
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
            return Tree.Kind.DIVIDE;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   906
        case MOD:               // %
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   907
            return Tree.Kind.REMAINDER;
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
06bc494ca11e Initial load
duke
parents:
diff changeset
   909
        // Additive operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   910
        case PLUS:              // +
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
            return Tree.Kind.PLUS;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   912
        case MINUS:             // -
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
            return Tree.Kind.MINUS;
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
        // Shift operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   916
        case SL:                // <<
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   917
            return Tree.Kind.LEFT_SHIFT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   918
        case SR:                // >>
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   919
            return Tree.Kind.RIGHT_SHIFT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   920
        case USR:               // >>>
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
            return Tree.Kind.UNSIGNED_RIGHT_SHIFT;
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
        // Relational operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   924
        case LT:                // <
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
            return Tree.Kind.LESS_THAN;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   926
        case GT:                // >
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   927
            return Tree.Kind.GREATER_THAN;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   928
        case LE:                // <=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
            return Tree.Kind.LESS_THAN_EQUAL;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   930
        case GE:                // >=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   931
            return Tree.Kind.GREATER_THAN_EQUAL;
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
        // Equality operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   934
        case EQ:                // ==
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
            return Tree.Kind.EQUAL_TO;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   936
        case NE:                // !=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   937
            return Tree.Kind.NOT_EQUAL_TO;
06bc494ca11e Initial load
duke
parents:
diff changeset
   938
06bc494ca11e Initial load
duke
parents:
diff changeset
   939
        // Bitwise and logical operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   940
        case BITAND:            // &
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   941
            return Tree.Kind.AND;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   942
        case BITXOR:            // ^
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   943
            return Tree.Kind.XOR;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   944
        case BITOR:             // |
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   945
            return Tree.Kind.OR;
06bc494ca11e Initial load
duke
parents:
diff changeset
   946
06bc494ca11e Initial load
duke
parents:
diff changeset
   947
        // Conditional operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   948
        case AND:               // &&
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   949
            return Tree.Kind.CONDITIONAL_AND;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   950
        case OR:                // ||
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   951
            return Tree.Kind.CONDITIONAL_OR;
06bc494ca11e Initial load
duke
parents:
diff changeset
   952
06bc494ca11e Initial load
duke
parents:
diff changeset
   953
        // Assignment operators
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   954
        case MUL_ASG:           // *=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   955
            return Tree.Kind.MULTIPLY_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   956
        case DIV_ASG:           // /=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   957
            return Tree.Kind.DIVIDE_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   958
        case MOD_ASG:           // %=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   959
            return Tree.Kind.REMAINDER_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   960
        case PLUS_ASG:          // +=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   961
            return Tree.Kind.PLUS_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   962
        case MINUS_ASG:         // -=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   963
            return Tree.Kind.MINUS_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   964
        case SL_ASG:            // <<=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   965
            return Tree.Kind.LEFT_SHIFT_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   966
        case SR_ASG:            // >>=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   967
            return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   968
        case USR_ASG:           // >>>=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   969
            return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   970
        case BITAND_ASG:        // &=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   971
            return Tree.Kind.AND_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   972
        case BITXOR_ASG:        // ^=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   973
            return Tree.Kind.XOR_ASSIGNMENT;
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   974
        case BITOR_ASG:         // |=
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
            return Tree.Kind.OR_ASSIGNMENT;
06bc494ca11e Initial load
duke
parents:
diff changeset
   976
06bc494ca11e Initial load
duke
parents:
diff changeset
   977
        // Null check (implementation detail), for example, __.getClass()
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   978
        case NULLCHK:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   979
            return Tree.Kind.OTHER;
06bc494ca11e Initial load
duke
parents:
diff changeset
   980
06bc494ca11e Initial load
duke
parents:
diff changeset
   981
        default:
06bc494ca11e Initial load
duke
parents:
diff changeset
   982
            return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   983
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
    }
3149
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   985
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   986
    /**
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   987
     * Returns the underlying type of the tree if it is annotated type,
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   988
     * or the tree itself otherwise
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   989
     */
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   990
    public static JCExpression typeIn(JCExpression tree) {
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   991
        switch (tree.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   992
        case IDENT: /* simple names */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   993
        case TYPEIDENT: /* primitive name */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   994
        case SELECT: /* qualified name */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   995
        case TYPEARRAY: /* array types */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   996
        case WILDCARD: /* wild cards */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   997
        case TYPEPARAMETER: /* type parameters */
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
   998
        case TYPEAPPLY: /* parameterized types */
3149
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
   999
            return tree;
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
  1000
        default:
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
  1001
            throw new AssertionError("Unexpected type tree: " + tree);
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
  1002
        }
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 1264
diff changeset
  1003
    }
4705
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1004
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1005
    public static JCTree innermostType(JCTree type) {
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1006
        switch (type.getTag()) {
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
  1007
        case TYPEARRAY:
4705
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1008
            return innermostType(((JCArrayTypeTree)type).elemtype);
10950
e87b50888909 6921494: provide way to print javac tree tag values
jjg
parents: 9300
diff changeset
  1009
        case WILDCARD:
4705
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1010
            return innermostType(((JCWildcard)type).inner);
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1011
        default:
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1012
            return type;
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1013
        }
7fac532dc6fa 6917122: provide utility method to find the inner most type of a type tree
jjg
parents: 3765
diff changeset
  1014
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1015
}