Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Sat Nov 05 00:02:33 2011 -0700
     1.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Tue Nov 08 11:51:05 2011 -0800
     1.3 @@ -325,7 +325,7 @@
     1.4              ListBuffer<TypeElement> elements = new ListBuffer<TypeElement>();
     1.5              for (JCCompilationUnit unit : units) {
     1.6                  for (JCTree node : unit.defs) {
     1.7 -                    if (node.getTag() == JCTree.CLASSDEF) {
     1.8 +                    if (node.hasTag(JCTree.Tag.CLASSDEF)) {
     1.9                          JCClassDecl cdef = (JCClassDecl) node;
    1.10                          if (cdef.sym != null) // maybe null if errors in anno processing
    1.11                              elements.append(cdef.sym);
    1.12 @@ -383,12 +383,12 @@
    1.13          private void handleFlowResults(Queue<Env<AttrContext>> queue, ListBuffer<Element> elems) {
    1.14              for (Env<AttrContext> env: queue) {
    1.15                  switch (env.tree.getTag()) {
    1.16 -                    case JCTree.CLASSDEF:
    1.17 +                    case CLASSDEF:
    1.18                          JCClassDecl cdef = (JCClassDecl) env.tree;
    1.19                          if (cdef.sym != null)
    1.20                              elems.append(cdef.sym);
    1.21                          break;
    1.22 -                    case JCTree.TOPLEVEL:
    1.23 +                    case TOPLEVEL:
    1.24                          JCCompilationUnit unit = (JCCompilationUnit) env.tree;
    1.25                          if (unit.packge != null)
    1.26                              elems.append(unit.packge);

     2.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTrees.java	Sat Nov 05 00:02:33 2011 -0700
     2.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTrees.java	Tue Nov 08 11:51:05 2011 -0800
     2.3 @@ -207,7 +207,7 @@
     2.4          if (sym == null && TreeInfo.isDeclaration(tree)) {
     2.5              for (TreePath p = path; p != null; p = p.getParentPath()) {
     2.6                  JCTree t = (JCTree) p.getLeaf();
     2.7 -                if (t.getTag() == JCTree.CLASSDEF) {
     2.8 +                if (t.hasTag(JCTree.Tag.CLASSDEF)) {
     2.9                      JCClassDecl ct = (JCClassDecl) t;
    2.10                      if (ct.sym != null) {
    2.11                          if ((ct.sym.flags_field & Flags.UNATTRIBUTED) != 0) {

     3.1 --- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Sat Nov 05 00:02:33 2011 -0700
     3.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Tue Nov 08 11:51:05 2011 -0800
     3.3 @@ -1,5 +1,5 @@
     3.4  /*
     3.5 - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
     3.6 + * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
     3.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3.8   *
     3.9   * This code is free software; you can redistribute it and/or modify it
    3.10 @@ -31,6 +31,8 @@
    3.11  import com.sun.tools.javac.tree.*;
    3.12  import com.sun.tools.javac.tree.JCTree.*;
    3.13  
    3.14 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    3.15 +
    3.16  /** Enter annotations on symbols.  Annotations accumulate in a queue,
    3.17   *  which is processed at the top level of any set of recursive calls
    3.18   *  requesting it be processed.
    3.19 @@ -148,7 +150,7 @@
    3.20              return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
    3.21          }
    3.22          List<JCExpression> args = a.args;
    3.23 -        if (args.length() == 1 && args.head.getTag() != JCTree.ASSIGN) {
    3.24 +        if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {
    3.25              // special case: elided "value=" assumed
    3.26              args.head = make.at(args.head.pos).
    3.27                  Assign(make.Ident(names.value), args.head);
    3.28 @@ -157,12 +159,12 @@
    3.29              new ListBuffer<Pair<MethodSymbol,Attribute>>();
    3.30          for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {
    3.31              JCExpression t = tl.head;
    3.32 -            if (t.getTag() != JCTree.ASSIGN) {
    3.33 +            if (!t.hasTag(ASSIGN)) {
    3.34                  log.error(t.pos(), "annotation.value.must.be.name.value");
    3.35                  continue;
    3.36              }
    3.37              JCAssign assign = (JCAssign)t;
    3.38 -            if (assign.lhs.getTag() != JCTree.IDENT) {
    3.39 +            if (!assign.lhs.hasTag(IDENT)) {
    3.40                  log.error(t.pos(), "annotation.value.must.be.name.value");
    3.41                  continue;
    3.42              }
    3.43 @@ -222,14 +224,14 @@
    3.44                                         (((JCFieldAccess) tree).selected).type);
    3.45          }
    3.46          if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {
    3.47 -            if (tree.getTag() != JCTree.ANNOTATION) {
    3.48 +            if (!tree.hasTag(ANNOTATION)) {
    3.49                  log.error(tree.pos(), "annotation.value.must.be.annotation");
    3.50                  expected = syms.errorType;
    3.51              }
    3.52              return enterAnnotation((JCAnnotation)tree, expected, env);
    3.53          }
    3.54          if (expected.tag == TypeTags.ARRAY) { // should really be isArray()
    3.55 -            if (tree.getTag() != JCTree.NEWARRAY) {
    3.56 +            if (!tree.hasTag(NEWARRAY)) {
    3.57                  tree = make.at(tree.pos).
    3.58                      NewArray(null, List.<JCExpression>nil(), List.of(tree));
    3.59              }

     4.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Sat Nov 05 00:02:33 2011 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Nov 08 11:51:05 2011 -0800
     4.3 @@ -49,8 +49,13 @@
     4.4  import com.sun.source.util.SimpleTreeVisitor;
     4.5  
     4.6  import static com.sun.tools.javac.code.Flags.*;
     4.7 +import static com.sun.tools.javac.code.Flags.ANNOTATION;
     4.8 +import static com.sun.tools.javac.code.Flags.BLOCK;
     4.9  import static com.sun.tools.javac.code.Kinds.*;
    4.10 +import static com.sun.tools.javac.code.Kinds.ERRONEOUS;
    4.11  import static com.sun.tools.javac.code.TypeTags.*;
    4.12 +import static com.sun.tools.javac.code.TypeTags.WILDCARD;
    4.13 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    4.14  
    4.15  /** This is the main context-dependent analysis phase in GJC. It
    4.16   *  encompasses name resolution, type checking and constant folding as
    4.17 @@ -245,7 +250,7 @@
    4.18              ((v.flags() & HASINIT) != 0
    4.19               ||
    4.20               !((base == null ||
    4.21 -               (base.getTag() == JCTree.IDENT && TreeInfo.name(base) == names._this)) &&
    4.22 +               (base.hasTag(IDENT) && TreeInfo.name(base) == names._this)) &&
    4.23                 isAssignableAsBlankFinal(v, env)))) {
    4.24              if (v.isResourceVariable()) { //TWR resource
    4.25                  log.error(pos, "try.resource.may.not.be.assigned", v);
    4.26 @@ -263,7 +268,7 @@
    4.27       *  @param tree    The candidate tree.
    4.28       */
    4.29      boolean isStaticReference(JCTree tree) {
    4.30 -        if (tree.getTag() == JCTree.SELECT) {
    4.31 +        if (tree.hasTag(SELECT)) {
    4.32              Symbol lsym = TreeInfo.symbol(((JCFieldAccess) tree).selected);
    4.33              if (lsym == null || lsym.kind != TYP) {
    4.34                  return false;
    4.35 @@ -693,7 +698,7 @@
    4.36              // disable implicit outer instance from being passed.
    4.37              // (This would be an illegal access to "this before super").
    4.38              if (env.info.isSelfCall &&
    4.39 -                env.tree.getTag() == JCTree.NEWCLASS &&
    4.40 +                env.tree.hasTag(NEWCLASS) &&
    4.41                  ((JCNewClass) env.tree).encl == null)
    4.42              {
    4.43                  c.flags_field |= NOOUTERTHIS;
    4.44 @@ -863,7 +868,7 @@
    4.45              chk.checkDeprecatedAnnotation(tree.pos(), v);
    4.46  
    4.47              if (tree.init != null) {
    4.48 -                if ((v.flags_field & FINAL) != 0 && tree.init.getTag() != JCTree.NEWCLASS) {
    4.49 +                if ((v.flags_field & FINAL) != 0 && !tree.init.hasTag(NEWCLASS)) {
    4.50                      // In this case, `v' is final.  Ensure that it's initializer is
    4.51                      // evaluated.
    4.52                      v.getConstValue(); // ensure initializer is evaluated
    4.53 @@ -971,8 +976,8 @@
    4.54      public void visitLabelled(JCLabeledStatement tree) {
    4.55          // Check that label is not used in an enclosing statement
    4.56          Env<AttrContext> env1 = env;
    4.57 -        while (env1 != null && env1.tree.getTag() != JCTree.CLASSDEF) {
    4.58 -            if (env1.tree.getTag() == JCTree.LABELLED &&
    4.59 +        while (env1 != null && !env1.tree.hasTag(CLASSDEF)) {
    4.60 +            if (env1.tree.hasTag(LABELLED) &&
    4.61                  ((JCLabeledStatement) env1.tree).label == tree.label) {
    4.62                  log.error(tree.pos(), "label.already.in.use",
    4.63                            tree.label);
    4.64 @@ -1052,14 +1057,14 @@
    4.65          private static void addVars(List<JCStatement> stats, Scope switchScope) {
    4.66              for (;stats.nonEmpty(); stats = stats.tail) {
    4.67                  JCTree stat = stats.head;
    4.68 -                if (stat.getTag() == JCTree.VARDEF)
    4.69 +                if (stat.hasTag(VARDEF))
    4.70                      switchScope.enter(((JCVariableDecl) stat).sym);
    4.71              }
    4.72          }
    4.73      // where
    4.74      /** Return the selected enumeration constant symbol, or null. */
    4.75      private Symbol enumConstant(JCTree tree, Type enumType) {
    4.76 -        if (tree.getTag() != JCTree.IDENT) {
    4.77 +        if (!tree.hasTag(IDENT)) {
    4.78              log.error(tree.pos(), "enum.label.must.be.unqualified.enum");
    4.79              return syms.errSymbol;
    4.80          }
    4.81 @@ -1094,7 +1099,7 @@
    4.82              localEnv;
    4.83          // Attribute resource declarations
    4.84          for (JCTree resource : tree.resources) {
    4.85 -            if (resource.getTag() == JCTree.VARDEF) {
    4.86 +            if (resource.hasTag(VARDEF)) {
    4.87                  attribStat(resource, tryEnv);
    4.88                  chk.checkType(resource, resource.type, syms.autoCloseableType, "try.not.applicable.to.type");
    4.89  
    4.90 @@ -1312,7 +1317,7 @@
    4.91           *  @param env     The environment current at the jump statement.
    4.92           */
    4.93          private JCTree findJumpTarget(DiagnosticPosition pos,
    4.94 -                                    int tag,
    4.95 +                                    JCTree.Tag tag,
    4.96                                      Name label,
    4.97                                      Env<AttrContext> env) {
    4.98              // Search environments outwards from the point of jump.
    4.99 @@ -1320,15 +1325,15 @@
   4.100              LOOP:
   4.101              while (env1 != null) {
   4.102                  switch (env1.tree.getTag()) {
   4.103 -                case JCTree.LABELLED:
   4.104 +                case LABELLED:
   4.105                      JCLabeledStatement labelled = (JCLabeledStatement)env1.tree;
   4.106                      if (label == labelled.label) {
   4.107                          // If jump is a continue, check that target is a loop.
   4.108 -                        if (tag == JCTree.CONTINUE) {
   4.109 -                            if (labelled.body.getTag() != JCTree.DOLOOP &&
   4.110 -                                labelled.body.getTag() != JCTree.WHILELOOP &&
   4.111 -                                labelled.body.getTag() != JCTree.FORLOOP &&
   4.112 -                                labelled.body.getTag() != JCTree.FOREACHLOOP)
   4.113 +                        if (tag == CONTINUE) {
   4.114 +                            if (!labelled.body.hasTag(DOLOOP) &&
   4.115 +                                !labelled.body.hasTag(WHILELOOP) &&
   4.116 +                                !labelled.body.hasTag(FORLOOP) &&
   4.117 +                                !labelled.body.hasTag(FOREACHLOOP))
   4.118                                  log.error(pos, "not.loop.label", label);
   4.119                              // Found labelled statement target, now go inwards
   4.120                              // to next non-labelled tree.
   4.121 @@ -1338,17 +1343,17 @@
   4.122                          }
   4.123                      }
   4.124                      break;
   4.125 -                case JCTree.DOLOOP:
   4.126 -                case JCTree.WHILELOOP:
   4.127 -                case JCTree.FORLOOP:
   4.128 -                case JCTree.FOREACHLOOP:
   4.129 +                case DOLOOP:
   4.130 +                case WHILELOOP:
   4.131 +                case FORLOOP:
   4.132 +                case FOREACHLOOP:
   4.133                      if (label == null) return env1.tree;
   4.134                      break;
   4.135 -                case JCTree.SWITCH:
   4.136 -                    if (label == null && tag == JCTree.BREAK) return env1.tree;
   4.137 +                case SWITCH:
   4.138 +                    if (label == null && tag == BREAK) return env1.tree;
   4.139                      break;
   4.140 -                case JCTree.METHODDEF:
   4.141 -                case JCTree.CLASSDEF:
   4.142 +                case METHODDEF:
   4.143 +                case CLASSDEF:
   4.144                      break LOOP;
   4.145                  default:
   4.146                  }
   4.147 @@ -1356,7 +1361,7 @@
   4.148              }
   4.149              if (label != null)
   4.150                  log.error(pos, "undef.label", label);
   4.151 -            else if (tag == JCTree.CONTINUE)
   4.152 +            else if (tag == CONTINUE)
   4.153                  log.error(pos, "cont.outside.loop");
   4.154              else
   4.155                  log.error(pos, "break.outside.switch.loop");
   4.156 @@ -1452,7 +1457,7 @@
   4.157                      if (encl.tag == CLASS) {
   4.158                          // we are calling a nested class
   4.159  
   4.160 -                        if (tree.meth.getTag() == JCTree.SELECT) {
   4.161 +                        if (tree.meth.hasTag(SELECT)) {
   4.162                              JCTree qualifier = ((JCFieldAccess) tree.meth).selected;
   4.163  
   4.164                              // We are seeing a prefixed call, of the form
   4.165 @@ -1468,7 +1473,7 @@
   4.166                              rs.resolveImplicitThis(tree.meth.pos(),
   4.167                                                     localEnv, site, true);
   4.168                          }
   4.169 -                    } else if (tree.meth.getTag() == JCTree.SELECT) {
   4.170 +                    } else if (tree.meth.hasTag(SELECT)) {
   4.171                          log.error(tree.meth.pos(), "illegal.qual.not.icls",
   4.172                                    site.tsym);
   4.173                      }
   4.174 @@ -1522,7 +1527,7 @@
   4.175  
   4.176              // as a special case, array.clone() has a result that is
   4.177              // the same as static type of the array being cloned
   4.178 -            if (tree.meth.getTag() == JCTree.SELECT &&
   4.179 +            if (tree.meth.hasTag(SELECT) &&
   4.180                  allowCovariantReturns &&
   4.181                  methName == names.clone &&
   4.182                  types.isArray(((JCFieldAccess) tree.meth).selected.type))
   4.183 @@ -1531,7 +1536,7 @@
   4.184              // as a special case, x.getClass() has type Class<? extends |X|>
   4.185              if (allowGenerics &&
   4.186                  methName == names.getClass && tree.args.isEmpty()) {
   4.187 -                Type qualifier = (tree.meth.getTag() == JCTree.SELECT)
   4.188 +                Type qualifier = (tree.meth.hasTag(SELECT))
   4.189                      ? ((JCFieldAccess) tree.meth).selected.type
   4.190                      : env.enclClass.sym.type;
   4.191                  restype = new
   4.192 @@ -1560,7 +1565,7 @@
   4.193              JCMethodDecl enclMethod = env.enclMethod;
   4.194              if (enclMethod != null && enclMethod.name == names.init) {
   4.195                  JCBlock body = enclMethod.body;
   4.196 -                if (body.stats.head.getTag() == JCTree.EXEC &&
   4.197 +                if (body.stats.head.hasTag(EXEC) &&
   4.198                      ((JCExpressionStatement) body.stats.head).expr == tree)
   4.199                      return true;
   4.200              }
   4.201 @@ -1591,7 +1596,7 @@
   4.202          // complete class name to be fully qualified
   4.203          JCExpression clazz = tree.clazz; // Class field following new
   4.204          JCExpression clazzid =          // Identifier in class field
   4.205 -            (clazz.getTag() == JCTree.TYPEAPPLY)
   4.206 +            (clazz.hasTag(TYPEAPPLY))
   4.207              ? ((JCTypeApply) clazz).clazz
   4.208              : clazz;
   4.209  
   4.210 @@ -1610,7 +1615,7 @@
   4.211                                               attribExpr(tree.encl, env));
   4.212              clazzid1 = make.at(clazz.pos).Select(make.Type(encltype),
   4.213                                                   ((JCIdent) clazzid).name);
   4.214 -            if (clazz.getTag() == JCTree.TYPEAPPLY)
   4.215 +            if (clazz.hasTag(TYPEAPPLY))
   4.216                  clazz = make.at(tree.pos).
   4.217                      TypeApply(clazzid1,
   4.218                                ((JCTypeApply) clazz).arguments);
   4.219 @@ -1689,7 +1694,7 @@
   4.220              // Enums may not be instantiated except implicitly
   4.221              if (allowEnums &&
   4.222                  (clazztype.tsym.flags_field&Flags.ENUM) != 0 &&
   4.223 -                (env.tree.getTag() != JCTree.VARDEF ||
   4.224 +                (!env.tree.hasTag(VARDEF) ||
   4.225                   (((JCVariableDecl) env.tree).mods.flags&Flags.ENUM) == 0 ||
   4.226                   ((JCVariableDecl) env.tree).init != tree))
   4.227                  log.error(tree.pos(), "enum.cant.be.instantiated");
   4.228 @@ -1930,7 +1935,7 @@
   4.229          Name name = TreeInfo.name(arg);
   4.230          if (name == names._this || name == names._super) return arg;
   4.231  
   4.232 -        int optag = JCTree.NULLCHK;
   4.233 +        JCTree.Tag optag = NULLCHK;
   4.234          JCUnary tree = make.at(arg.pos).Unary(optag, arg);
   4.235          tree.operator = syms.nullcheck;
   4.236          tree.type = arg.type;
   4.237 @@ -1991,7 +1996,7 @@
   4.238          Type operand = attribExpr(tree.rhs, env);
   4.239          // Find operator.
   4.240          Symbol operator = tree.operator = rs.resolveBinaryOperator(
   4.241 -            tree.pos(), tree.getTag() - JCTree.ASGOffset, env,
   4.242 +            tree.pos(), tree.getTag().noAssignOp(), env,
   4.243              owntype, operand);
   4.244  
   4.245          if (operator.kind == MTH &&
   4.246 @@ -1999,7 +2004,7 @@
   4.247                  !operand.isErroneous()) {
   4.248              chk.checkOperator(tree.pos(),
   4.249                                (OperatorSymbol)operator,
   4.250 -                              tree.getTag() - JCTree.ASGOffset,
   4.251 +                              tree.getTag().noAssignOp(),
   4.252                                owntype,
   4.253                                operand);
   4.254              chk.checkDivZero(tree.rhs.pos(), operator, operand);
   4.255 @@ -2012,7 +2017,7 @@
   4.256  
   4.257      public void visitUnary(JCUnary tree) {
   4.258          // Attribute arguments.
   4.259 -        Type argtype = (JCTree.PREINC <= tree.getTag() && tree.getTag() <= JCTree.POSTDEC)
   4.260 +        Type argtype = (tree.getTag().isIncOrDecUnaryOp())
   4.261              ? attribTree(tree.arg, env, VAR, Type.noType)
   4.262              : chk.checkNonVoid(tree.arg.pos(), attribExpr(tree.arg, env));
   4.263  
   4.264 @@ -2023,7 +2028,7 @@
   4.265          Type owntype = types.createErrorType(tree.type);
   4.266          if (operator.kind == MTH &&
   4.267                  !argtype.isErroneous()) {
   4.268 -            owntype = (JCTree.PREINC <= tree.getTag() && tree.getTag() <= JCTree.POSTDEC)
   4.269 +            owntype = (tree.getTag().isIncOrDecUnaryOp())
   4.270                  ? tree.arg.type
   4.271                  : operator.type.getReturnType();
   4.272              int opc = ((OperatorSymbol)operator).opcode;
   4.273 @@ -2621,7 +2626,7 @@
   4.274                  canOwnInitializer(env.info.scope.owner) &&
   4.275                  v.owner == env.info.scope.owner.enclClass() &&
   4.276                  ((v.flags() & STATIC) != 0) == Resolve.isStatic(env) &&
   4.277 -                (env.tree.getTag() != JCTree.ASSIGN ||
   4.278 +                (!env.tree.hasTag(ASSIGN) ||
   4.279                   TreeInfo.skipParens(((JCAssign) env.tree).lhs) != tree)) {
   4.280                  String suffix = (env.info.enclVar == v) ?
   4.281                                  "self.ref" : "forward.ref";
   4.282 @@ -2812,10 +2817,10 @@
   4.283                  }
   4.284                  Type elemtype = types.elemtype(argtype);
   4.285                  switch (tree.getTag()) {
   4.286 -                case JCTree.APPLY:
   4.287 +                case APPLY:
   4.288                      ((JCMethodInvocation) tree).varargsElement = elemtype;
   4.289                      break;
   4.290 -                case JCTree.NEWCLASS:
   4.291 +                case NEWCLASS:
   4.292                      ((JCNewClass) tree).varargsElement = elemtype;
   4.293                      break;
   4.294                  default:
   4.295 @@ -2896,9 +2901,9 @@
   4.296                  if (clazzOuter.tag == CLASS) {
   4.297                      Type site;
   4.298                      JCExpression clazz = TreeInfo.typeIn(tree.clazz);
   4.299 -                    if (clazz.getTag() == JCTree.IDENT) {
   4.300 +                    if (clazz.hasTag(IDENT)) {
   4.301                          site = env.enclClass.sym.type;
   4.302 -                    } else if (clazz.getTag() == JCTree.SELECT) {
   4.303 +                    } else if (clazz.hasTag(SELECT)) {
   4.304                          site = ((JCFieldAccess) clazz).selected.type;
   4.305                      } else throw new AssertionError(""+tree);
   4.306                      if (clazzOuter.tag == CLASS && site != clazzOuter) {
   4.307 @@ -3068,7 +3073,7 @@
   4.308       * Attribute an env for either a top level tree or class declaration.
   4.309       */
   4.310      public void attrib(Env<AttrContext> env) {
   4.311 -        if (env.tree.getTag() == JCTree.TOPLEVEL)
   4.312 +        if (env.tree.hasTag(TOPLEVEL))
   4.313              attribTopLevel(env);
   4.314          else
   4.315              attribClass(env.tree.pos(), env.enclClass.sym);
   4.316 @@ -3245,7 +3250,7 @@
   4.317                  ((c.flags() & STATIC) == 0 || c.name == names.empty) &&
   4.318                  (TreeInfo.flags(l.head) & (STATIC | INTERFACE)) != 0) {
   4.319                  Symbol sym = null;
   4.320 -                if (l.head.getTag() == JCTree.VARDEF) sym = ((JCVariableDecl) l.head).sym;
   4.321 +                if (l.head.hasTag(VARDEF)) sym = ((JCVariableDecl) l.head).sym;
   4.322                  if (sym == null ||
   4.323                      sym.kind != VAR ||
   4.324                      ((VarSymbol) sym).getConstValue() == null)

     5.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Sat Nov 05 00:02:33 2011 -0700
     5.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue Nov 08 11:51:05 2011 -0800
     5.3 @@ -42,10 +42,14 @@
     5.4  import com.sun.tools.javac.code.Symbol.*;
     5.5  
     5.6  import static com.sun.tools.javac.code.Flags.*;
     5.7 +import static com.sun.tools.javac.code.Flags.ANNOTATION;
     5.8 +import static com.sun.tools.javac.code.Flags.SYNCHRONIZED;
     5.9  import static com.sun.tools.javac.code.Kinds.*;
    5.10  import static com.sun.tools.javac.code.TypeTags.*;
    5.11 +import static com.sun.tools.javac.code.TypeTags.WILDCARD;
    5.12  
    5.13  import static com.sun.tools.javac.main.OptionName.*;
    5.14 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    5.15  
    5.16  /** Type checking helper class for the attribution phase.
    5.17   *
    5.18 @@ -987,7 +991,7 @@
    5.19       *  <i>not</i> final.
    5.20       */
    5.21      private long implicitEnumFinalFlag(JCTree tree) {
    5.22 -        if (tree.getTag() != JCTree.CLASSDEF) return 0;
    5.23 +        if (!tree.hasTag(CLASSDEF)) return 0;
    5.24          class SpecialTreeVisitor extends JCTree.Visitor {
    5.25              boolean specialized;
    5.26              SpecialTreeVisitor() {
    5.27 @@ -1099,7 +1103,7 @@
    5.28                  // not parameterized at all.
    5.29                  if (tree.type.getEnclosingType().isRaw())
    5.30                      log.error(tree.pos(), "improperly.formed.type.inner.raw.param");
    5.31 -                if (tree.clazz.getTag() == JCTree.SELECT)
    5.32 +                if (tree.clazz.hasTag(SELECT))
    5.33                      visitSelectInternal((JCFieldAccess)tree.clazz);
    5.34              }
    5.35          }
    5.36 @@ -2413,7 +2417,7 @@
    5.37  
    5.38          // count them off as they're annotated
    5.39          for (JCTree arg : a.args) {
    5.40 -            if (arg.getTag() != JCTree.ASSIGN) continue; // recovery
    5.41 +            if (!arg.hasTag(ASSIGN)) continue; // recovery
    5.42              JCAssign assign = (JCAssign) arg;
    5.43              Symbol m = TreeInfo.symbol(assign.lhs);
    5.44              if (m == null || m.type.isErroneous()) continue;
    5.45 @@ -2442,12 +2446,12 @@
    5.46              a.args.tail == null)
    5.47              return;
    5.48  
    5.49 -        if (a.args.head.getTag() != JCTree.ASSIGN) return; // error recovery
    5.50 +        if (!a.args.head.hasTag(ASSIGN)) return; // error recovery
    5.51          JCAssign assign = (JCAssign) a.args.head;
    5.52          Symbol m = TreeInfo.symbol(assign.lhs);
    5.53          if (m.name != names.value) return;
    5.54          JCTree rhs = assign.rhs;
    5.55 -        if (rhs.getTag() != JCTree.NEWARRAY) return;
    5.56 +        if (!rhs.hasTag(NEWARRAY)) return;
    5.57          JCNewArray na = (JCNewArray) rhs;
    5.58          Set<Symbol> targets = new HashSet<Symbol>();
    5.59          for (JCTree elem : na.elems) {
    5.60 @@ -2506,7 +2510,7 @@
    5.61          try {
    5.62              tree.sym.flags_field |= LOCKED;
    5.63              for (JCTree def : tree.defs) {
    5.64 -                if (def.getTag() != JCTree.METHODDEF) continue;
    5.65 +                if (!def.hasTag(METHODDEF)) continue;
    5.66                  JCMethodDecl meth = (JCMethodDecl)def;
    5.67                  checkAnnotationResType(meth.pos(), meth.restype.type);
    5.68              }
    5.69 @@ -2614,7 +2618,7 @@
    5.70       */
    5.71      int checkOperator(DiagnosticPosition pos,
    5.72                         OperatorSymbol operator,
    5.73 -                       int tag,
    5.74 +                       JCTree.Tag tag,
    5.75                         Type left,
    5.76                         Type right) {
    5.77          if (operator.opcode == ByteCodes.error) {
    5.78 @@ -2650,7 +2654,8 @@
    5.79       * Check for empty statements after if
    5.80       */
    5.81      void checkEmptyIf(JCIf tree) {
    5.82 -        if (tree.thenpart.getTag() == JCTree.SKIP && tree.elsepart == null && lint.isEnabled(LintCategory.EMPTY))
    5.83 +        if (tree.thenpart.hasTag(SKIP) && tree.elsepart == null &&
    5.84 +                lint.isEnabled(LintCategory.EMPTY))
    5.85              log.warning(LintCategory.EMPTY, tree.thenpart.pos(), "empty.if");
    5.86      }
    5.87  
    5.88 @@ -2754,7 +2759,7 @@
    5.89      }
    5.90          // where
    5.91          private boolean isCanonical(JCTree tree) {
    5.92 -            while (tree.getTag() == JCTree.SELECT) {
    5.93 +            while (tree.hasTag(SELECT)) {
    5.94                  JCFieldAccess s = (JCFieldAccess) tree;
    5.95                  if (s.sym.owner != TreeInfo.symbol(s.selected))
    5.96                      return false;

     6.1 --- a/src/share/classes/com/sun/tools/javac/comp/Enter.java	Sat Nov 05 00:02:33 2011 -0700
     6.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Enter.java	Tue Nov 08 11:51:05 2011 -0800
     6.3 @@ -228,7 +228,7 @@
     6.4       *  only, and members go into the class member scope.
     6.5       */
     6.6      Scope enterScope(Env<AttrContext> env) {
     6.7 -        return (env.tree.getTag() == JCTree.CLASSDEF)
     6.8 +        return (env.tree.hasTag(JCTree.Tag.CLASSDEF))
     6.9              ? ((JCClassDecl) env.tree).sym.members_field
    6.10              : env.info.scope;
    6.11      }

     7.1 --- a/src/share/classes/com/sun/tools/javac/comp/Env.java	Sat Nov 05 00:02:33 2011 -0700
     7.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Env.java	Tue Nov 08 11:51:05 2011 -0800
     7.3 @@ -1,5 +1,5 @@
     7.4  /*
     7.5 - * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
     7.6 + * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
     7.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.8   *
     7.9   * This code is free software; you can redistribute it and/or modify it
    7.10 @@ -116,9 +116,9 @@
    7.11  
    7.12      /** Return closest enclosing environment which points to a tree with given tag.
    7.13       */
    7.14 -    public Env<A> enclosing(int tag) {
    7.15 +    public Env<A> enclosing(JCTree.Tag tag) {
    7.16          Env<A> env1 = this;
    7.17 -        while (env1 != null && env1.tree.getTag() != tag) env1 = env1.next;
    7.18 +        while (env1 != null && !env1.tree.hasTag(tag)) env1 = env1.next;
    7.19          return env1;
    7.20      }
    7.21  

     8.1 --- a/src/share/classes/com/sun/tools/javac/comp/Flow.java	Sat Nov 05 00:02:33 2011 -0700
     8.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Flow.java	Tue Nov 08 11:51:05 2011 -0800
     8.3 @@ -40,8 +40,10 @@
     8.4  import com.sun.tools.javac.tree.JCTree.*;
     8.5  
     8.6  import static com.sun.tools.javac.code.Flags.*;
     8.7 +import static com.sun.tools.javac.code.Flags.BLOCK;
     8.8  import static com.sun.tools.javac.code.Kinds.*;
     8.9  import static com.sun.tools.javac.code.TypeTags.*;
    8.10 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    8.11  
    8.12  /** This pass implements dataflow analysis for Java programs.
    8.13   *  Liveness analysis checks that every statement is reachable.
    8.14 @@ -321,7 +323,7 @@
    8.15                  log.error(exit.tree.pos(),
    8.16                          "unreported.exception.default.constructor",
    8.17                          exit.thrown);
    8.18 -            } else if (exit.tree.getTag() == JCTree.VARDEF &&
    8.19 +            } else if (exit.tree.hasTag(VARDEF) &&
    8.20                      ((JCVariableDecl)exit.tree).sym.isResourceVariable()) {
    8.21                  log.error(exit.tree.pos(),
    8.22                          "unreported.exception.implicit.close",
    8.23 @@ -416,7 +418,7 @@
    8.24       */
    8.25      void letInit(JCTree tree) {
    8.26          tree = TreeInfo.skipParens(tree);
    8.27 -        if (tree.getTag() == JCTree.IDENT || tree.getTag() == JCTree.SELECT) {
    8.28 +        if (tree.hasTag(IDENT) || tree.hasTag(SELECT)) {
    8.29              Symbol sym = TreeInfo.symbol(tree);
    8.30              if (sym.kind == VAR) {
    8.31                  letInit(tree.pos(), (VarSymbol)sym);
    8.32 @@ -452,7 +454,7 @@
    8.33          pendingExits = oldPendingExits;
    8.34          for (; exits.nonEmpty(); exits = exits.tail) {
    8.35              PendingExit exit = exits.head;
    8.36 -            if (exit.tree.getTag() == JCTree.BREAK &&
    8.37 +            if (exit.tree.hasTag(BREAK) &&
    8.38                  ((JCBreak) exit.tree).target == tree) {
    8.39                  inits.andSet(exit.inits);
    8.40                  uninits.andSet(exit.uninits);
    8.41 @@ -471,7 +473,7 @@
    8.42          pendingExits = new ListBuffer<PendingExit>();
    8.43          for (; exits.nonEmpty(); exits = exits.tail) {
    8.44              PendingExit exit = exits.head;
    8.45 -            if (exit.tree.getTag() == JCTree.CONTINUE &&
    8.46 +            if (exit.tree.hasTag(CONTINUE) &&
    8.47                  ((JCContinue) exit.tree).target == tree) {
    8.48                  inits.andSet(exit.inits);
    8.49                  uninits.andSet(exit.uninits);
    8.50 @@ -517,7 +519,7 @@
    8.51       */
    8.52      void scanDef(JCTree tree) {
    8.53          scanStat(tree);
    8.54 -        if (tree != null && tree.getTag() == JCTree.BLOCK && !alive) {
    8.55 +        if (tree != null && tree.hasTag(JCTree.Tag.BLOCK) && !alive) {
    8.56              log.error(tree.pos(),
    8.57                        "initializer.must.be.able.to.complete.normally");
    8.58          }
    8.59 @@ -528,7 +530,7 @@
    8.60      void scanStat(JCTree tree) {
    8.61          if (!alive && tree != null) {
    8.62              log.error(tree.pos(), "unreachable.stmt");
    8.63 -            if (tree.getTag() != JCTree.SKIP) alive = true;
    8.64 +            if (!tree.hasTag(SKIP)) alive = true;
    8.65          }
    8.66          scan(tree);
    8.67      }
    8.68 @@ -614,7 +616,7 @@
    8.69          try {
    8.70              // define all the static fields
    8.71              for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
    8.72 -                if (l.head.getTag() == JCTree.VARDEF) {
    8.73 +                if (l.head.hasTag(VARDEF)) {
    8.74                      JCVariableDecl def = (JCVariableDecl)l.head;
    8.75                      if ((def.mods.flags & STATIC) != 0) {
    8.76                          VarSymbol sym = def.sym;
    8.77 @@ -626,7 +628,7 @@
    8.78  
    8.79              // process all the static initializers
    8.80              for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
    8.81 -                if (l.head.getTag() != JCTree.METHODDEF &&
    8.82 +                if (!l.head.hasTag(METHODDEF) &&
    8.83                      (TreeInfo.flags(l.head) & STATIC) != 0) {
    8.84                      scanDef(l.head);
    8.85                      errorUncaught();
    8.86 @@ -653,7 +655,7 @@
    8.87  
    8.88              // define all the instance fields
    8.89              for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
    8.90 -                if (l.head.getTag() == JCTree.VARDEF) {
    8.91 +                if (l.head.hasTag(VARDEF)) {
    8.92                      JCVariableDecl def = (JCVariableDecl)l.head;
    8.93                      if ((def.mods.flags & STATIC) == 0) {
    8.94                          VarSymbol sym = def.sym;
    8.95 @@ -665,7 +667,7 @@
    8.96  
    8.97              // process all the instance initializers
    8.98              for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
    8.99 -                if (l.head.getTag() != JCTree.METHODDEF &&
   8.100 +                if (!l.head.hasTag(METHODDEF) &&
   8.101                      (TreeInfo.flags(l.head) & STATIC) == 0) {
   8.102                      scanDef(l.head);
   8.103                      errorUncaught();
   8.104 @@ -691,7 +693,7 @@
   8.105  
   8.106              // process all the methods
   8.107              for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
   8.108 -                if (l.head.getTag() == JCTree.METHODDEF) {
   8.109 +                if (l.head.hasTag(METHODDEF)) {
   8.110                      scan(l.head);
   8.111                      errorUncaught();
   8.112                  }
   8.113 @@ -760,7 +762,7 @@
   8.114                  PendingExit exit = exits.head;
   8.115                  exits = exits.tail;
   8.116                  if (exit.thrown == null) {
   8.117 -                    Assert.check(exit.tree.getTag() == JCTree.RETURN);
   8.118 +                    Assert.check(exit.tree.hasTag(RETURN));
   8.119                      if (isInitialConstructor) {
   8.120                          inits = exit.inits;
   8.121                          for (int i = firstadr; i < nextadr; i++)
   8.122 @@ -989,7 +991,7 @@
   8.123                                      Bits uninits) {
   8.124              for (;stats.nonEmpty(); stats = stats.tail) {
   8.125                  JCTree stat = stats.head;
   8.126 -                if (stat.getTag() == JCTree.VARDEF) {
   8.127 +                if (stat.hasTag(VARDEF)) {
   8.128                      int adr = ((JCVariableDecl) stat).sym.adr;
   8.129                      inits.excl(adr);
   8.130                      uninits.incl(adr);
   8.131 @@ -1346,7 +1348,7 @@
   8.132  
   8.133      public void visitUnary(JCUnary tree) {
   8.134          switch (tree.getTag()) {
   8.135 -        case JCTree.NOT:
   8.136 +        case NOT:
   8.137              scanCond(tree.arg);
   8.138              Bits t = initsWhenFalse;
   8.139              initsWhenFalse = initsWhenTrue;
   8.140 @@ -1355,8 +1357,8 @@
   8.141              uninitsWhenFalse = uninitsWhenTrue;
   8.142              uninitsWhenTrue = t;
   8.143              break;
   8.144 -        case JCTree.PREINC: case JCTree.POSTINC:
   8.145 -        case JCTree.PREDEC: case JCTree.POSTDEC:
   8.146 +        case PREINC: case POSTINC:
   8.147 +        case PREDEC: case POSTDEC:
   8.148              scanExpr(tree.arg);
   8.149              letInit(tree.arg);
   8.150              break;
   8.151 @@ -1367,7 +1369,7 @@
   8.152  
   8.153      public void visitBinary(JCBinary tree) {
   8.154          switch (tree.getTag()) {
   8.155 -        case JCTree.AND:
   8.156 +        case AND:
   8.157              scanCond(tree.lhs);
   8.158              Bits initsWhenFalseLeft = initsWhenFalse;
   8.159              Bits uninitsWhenFalseLeft = uninitsWhenFalse;
   8.160 @@ -1377,7 +1379,7 @@
   8.161              initsWhenFalse.andSet(initsWhenFalseLeft);
   8.162              uninitsWhenFalse.andSet(uninitsWhenFalseLeft);
   8.163              break;
   8.164 -        case JCTree.OR:
   8.165 +        case OR:
   8.166              scanCond(tree.lhs);
   8.167              Bits initsWhenTrueLeft = initsWhenTrue;
   8.168              Bits uninitsWhenTrueLeft = uninitsWhenTrue;
   8.169 @@ -1418,7 +1420,7 @@
   8.170          private boolean is292targetTypeCast(JCTypeCast tree) {
   8.171              boolean is292targetTypeCast = false;
   8.172              JCExpression expr = TreeInfo.skipParens(tree.expr);
   8.173 -            if (expr.getTag() == JCTree.APPLY) {
   8.174 +            if (expr.hasTag(APPLY)) {
   8.175                  JCMethodInvocation apply = (JCMethodInvocation)expr;
   8.176                  Symbol sym = TreeInfo.symbol(apply.meth);
   8.177                  is292targetTypeCast = sym != null &&

     9.1 --- a/src/share/classes/com/sun/tools/javac/comp/Infer.java	Sat Nov 05 00:02:33 2011 -0700
     9.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Infer.java	Tue Nov 08 11:51:05 2011 -0800
     9.3 @@ -633,13 +633,13 @@
     9.4          //the polymorphic signature call environment is nested.
     9.5  
     9.6          switch (env.next.tree.getTag()) {
     9.7 -            case JCTree.TYPECAST:
     9.8 +            case TYPECAST:
     9.9                  JCTypeCast castTree = (JCTypeCast)env.next.tree;
    9.10                  restype = (TreeInfo.skipParens(castTree.expr) == env.tree) ?
    9.11                      castTree.clazz.type :
    9.12                      syms.objectType;
    9.13                  break;
    9.14 -            case JCTree.EXEC:
    9.15 +            case EXEC:
    9.16                  JCTree.JCExpressionStatement execTree =
    9.17                          (JCTree.JCExpressionStatement)env.next.tree;
    9.18                  restype = (TreeInfo.skipParens(execTree.expr) == env.tree) ?

    10.1 --- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Sat Nov 05 00:02:33 2011 -0700
    10.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Tue Nov 08 11:51:05 2011 -0800
    10.3 @@ -42,9 +42,11 @@
    10.4  import com.sun.tools.javac.jvm.Target;
    10.5  
    10.6  import static com.sun.tools.javac.code.Flags.*;
    10.7 +import static com.sun.tools.javac.code.Flags.BLOCK;
    10.8  import static com.sun.tools.javac.code.Kinds.*;
    10.9  import static com.sun.tools.javac.code.TypeTags.*;
   10.10  import static com.sun.tools.javac.jvm.ByteCodes.*;
   10.11 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   10.12  
   10.13  /** This pass translates away some syntactic sugar: inner classes,
   10.14   *  class literals, assertions, foreach loops, etc.
   10.15 @@ -303,7 +305,7 @@
   10.16                  Symbol constructor = TreeInfo.symbol(tree.meth);
   10.17                  ClassSymbol c = (ClassSymbol)constructor.owner;
   10.18                  if (c.hasOuterInstance() &&
   10.19 -                    tree.meth.getTag() != JCTree.SELECT &&
   10.20 +                    !tree.meth.hasTag(SELECT) &&
   10.21                      outerThisStack.head != null)
   10.22                      visitSymbol(outerThisStack.head);
   10.23              }
   10.24 @@ -508,7 +510,7 @@
   10.25       *  @param optag    The operators tree tag.
   10.26       *  @param arg      The operator's argument.
   10.27       */
   10.28 -    JCUnary makeUnary(int optag, JCExpression arg) {
   10.29 +    JCUnary makeUnary(JCTree.Tag optag, JCExpression arg) {
   10.30          JCUnary tree = make.Unary(optag, arg);
   10.31          tree.operator = rs.resolveUnaryOperator(
   10.32              make_pos, optag, attrEnv, arg.type);
   10.33 @@ -521,7 +523,7 @@
   10.34       *  @param lhs      The operator's left argument.
   10.35       *  @param rhs      The operator's right argument.
   10.36       */
   10.37 -    JCBinary makeBinary(int optag, JCExpression lhs, JCExpression rhs) {
   10.38 +    JCBinary makeBinary(JCTree.Tag optag, JCExpression lhs, JCExpression rhs) {
   10.39          JCBinary tree = make.Binary(optag, lhs, rhs);
   10.40          tree.operator = rs.resolveBinaryOperator(
   10.41              make_pos, optag, attrEnv, lhs.type, rhs.type);
   10.42 @@ -534,10 +536,10 @@
   10.43       *  @param lhs      The operator's left argument.
   10.44       *  @param rhs      The operator's right argument.
   10.45       */
   10.46 -    JCAssignOp makeAssignop(int optag, JCTree lhs, JCTree rhs) {
   10.47 +    JCAssignOp makeAssignop(JCTree.Tag optag, JCTree lhs, JCTree rhs) {
   10.48          JCAssignOp tree = make.Assignop(optag, lhs, rhs);
   10.49          tree.operator = rs.resolveBinaryOperator(
   10.50 -            make_pos, tree.getTag() - JCTree.ASGOffset, attrEnv, lhs.type, rhs.type);
   10.51 +            make_pos, tree.getTag().noAssignOp(), attrEnv, lhs.type, rhs.type);
   10.52          tree.type = lhs.type;
   10.53          return tree;
   10.54      }
   10.55 @@ -720,7 +722,7 @@
   10.56      // where
   10.57      private boolean isTranslatedClassAvailable(ClassSymbol c) {
   10.58          for (JCTree tree: translated) {
   10.59 -            if (tree.getTag() == JCTree.CLASSDEF
   10.60 +            if (tree.hasTag(CLASSDEF)
   10.61                      && ((JCClassDecl) tree).sym == c) {
   10.62                  return true;
   10.63              }
   10.64 @@ -802,13 +804,13 @@
   10.65      private static int accessCode(JCTree tree, JCTree enclOp) {
   10.66          if (enclOp == null)
   10.67              return DEREFcode;
   10.68 -        else if (enclOp.getTag() == JCTree.ASSIGN &&
   10.69 +        else if (enclOp.hasTag(ASSIGN) &&
   10.70                   tree == TreeInfo.skipParens(((JCAssign) enclOp).lhs))
   10.71              return ASSIGNcode;
   10.72 -        else if (JCTree.PREINC <= enclOp.getTag() && enclOp.getTag() <= JCTree.POSTDEC &&
   10.73 +        else if (enclOp.getTag().isIncOrDecUnaryOp() &&
   10.74                   tree == TreeInfo.skipParens(((JCUnary) enclOp).arg))
   10.75 -            return (enclOp.getTag() - JCTree.PREINC) * 2 + PREINCcode;
   10.76 -        else if (JCTree.BITOR_ASG <= enclOp.getTag() && enclOp.getTag() <= JCTree.MOD_ASG &&
   10.77 +            return mapTagToUnaryOpCode(enclOp.getTag());
   10.78 +        else if (enclOp.getTag().isAssignop() &&
   10.79                   tree == TreeInfo.skipParens(((JCAssignOp) enclOp).lhs))
   10.80              return accessCode(((OperatorSymbol) ((JCAssignOp) enclOp).operator).opcode);
   10.81          else
   10.82 @@ -832,39 +834,39 @@
   10.83      /** Return tree tag for assignment operation corresponding
   10.84       *  to given binary operator.
   10.85       */
   10.86 -    private static int treeTag(OperatorSymbol operator) {
   10.87 +    private static JCTree.Tag treeTag(OperatorSymbol operator) {
   10.88          switch (operator.opcode) {
   10.89          case ByteCodes.ior: case ByteCodes.lor:
   10.90 -            return JCTree.BITOR_ASG;
   10.91 +            return BITOR_ASG;
   10.92          case ByteCodes.ixor: case ByteCodes.lxor:
   10.93 -            return JCTree.BITXOR_ASG;
   10.94 +            return BITXOR_ASG;
   10.95          case ByteCodes.iand: case ByteCodes.land:
   10.96 -            return JCTree.BITAND_ASG;
   10.97 +            return BITAND_ASG;
   10.98          case ByteCodes.ishl: case ByteCodes.lshl:
   10.99          case ByteCodes.ishll: case ByteCodes.lshll:
  10.100 -            return JCTree.SL_ASG;
  10.101 +            return SL_ASG;
  10.102          case ByteCodes.ishr: case ByteCodes.lshr:
  10.103          case ByteCodes.ishrl: case ByteCodes.lshrl:
  10.104 -            return JCTree.SR_ASG;
  10.105 +            return SR_ASG;
  10.106          case ByteCodes.iushr: case ByteCodes.lushr:
  10.107          case ByteCodes.iushrl: case ByteCodes.lushrl:
  10.108 -            return JCTree.USR_ASG;
  10.109 +            return USR_ASG;
  10.110          case ByteCodes.iadd: case ByteCodes.ladd:
  10.111          case ByteCodes.fadd: case ByteCodes.dadd:
  10.112          case ByteCodes.string_add:
  10.113 -            return JCTree.PLUS_ASG;
  10.114 +            return PLUS_ASG;
  10.115          case ByteCodes.isub: case ByteCodes.lsub:
  10.116          case ByteCodes.fsub: case ByteCodes.dsub:
  10.117 -            return JCTree.MINUS_ASG;
  10.118 +            return MINUS_ASG;
  10.119          case ByteCodes.imul: case ByteCodes.lmul:
  10.120          case ByteCodes.fmul: case ByteCodes.dmul:
  10.121 -            return JCTree.MUL_ASG;
  10.122 +            return MUL_ASG;
  10.123          case ByteCodes.idiv: case ByteCodes.ldiv:
  10.124          case ByteCodes.fdiv: case ByteCodes.ddiv:
  10.125 -            return JCTree.DIV_ASG;
  10.126 +            return DIV_ASG;
  10.127          case ByteCodes.imod: case ByteCodes.lmod:
  10.128          case ByteCodes.fmod: case ByteCodes.dmod:
  10.129 -            return JCTree.MOD_ASG;
  10.130 +            return MOD_ASG;
  10.131          default:
  10.132              throw new AssertionError();
  10.133          }
  10.134 @@ -1003,7 +1005,7 @@
  10.135          if (!currentClass.isSubClass(sym.owner, types))
  10.136              return true;
  10.137          if ((sym.flags() & STATIC) != 0 ||
  10.138 -            tree.getTag() != JCTree.SELECT ||
  10.139 +            !tree.hasTag(SELECT) ||
  10.140              TreeInfo.name(((JCFieldAccess) tree).selected) == names._super)
  10.141              return false;
  10.142          return !((JCFieldAccess) tree).selected.type.tsym.isSubClass(currentClass, types);
  10.143 @@ -1018,7 +1020,7 @@
  10.144          if (protAccess) {
  10.145              Symbol qualifier = null;
  10.146              ClassSymbol c = currentClass;
  10.147 -            if (tree.getTag() == JCTree.SELECT && (sym.flags() & STATIC) == 0) {
  10.148 +            if (tree.hasTag(SELECT) && (sym.flags() & STATIC) == 0) {
  10.149                  qualifier = ((JCFieldAccess) tree).selected.type.tsym;
  10.150                  while (!qualifier.isSubClass(c, types)) {
  10.151                      c = c.owner.enclClass();
  10.152 @@ -1058,7 +1060,7 @@
  10.153              Assert.check(sym != null && (sym.flags_field & FINAL) != 0);
  10.154              tree = make.at(tree.pos).Ident(sym);
  10.155          }
  10.156 -        JCExpression base = (tree.getTag() == JCTree.SELECT) ? ((JCFieldAccess) tree).selected : null;
  10.157 +        JCExpression base = (tree.hasTag(SELECT)) ? ((JCFieldAccess) tree).selected : null;
  10.158          switch (sym.kind) {
  10.159          case TYP:
  10.160              if (sym.owner.kind != PCK) {
  10.161 @@ -1068,11 +1070,11 @@
  10.162                  while (base != null &&
  10.163                         TreeInfo.symbol(base) != null &&
  10.164                         TreeInfo.symbol(base).kind != PCK) {
  10.165 -                    base = (base.getTag() == JCTree.SELECT)
  10.166 +                    base = (base.hasTag(SELECT))
  10.167                          ? ((JCFieldAccess) base).selected
  10.168                          : null;
  10.169                  }
  10.170 -                if (tree.getTag() == JCTree.IDENT) {
  10.171 +                if (tree.hasTag(IDENT)) {
  10.172                      ((JCIdent) tree).name = flatname;
  10.173                  } else if (base == null) {
  10.174                      tree = make.at(tree.pos).Ident(sym);
  10.175 @@ -1220,6 +1222,42 @@
  10.176          }
  10.177      }
  10.178  
  10.179 +    /** Maps unary operator integer codes to JCTree.Tag objects
  10.180 +     *  @param unaryOpCode the unary operator code
  10.181 +     */
  10.182 +    private static Tag mapUnaryOpCodeToTag(int unaryOpCode){
  10.183 +        switch (unaryOpCode){
  10.184 +            case PREINCcode:
  10.185 +                return PREINC;
  10.186 +            case PREDECcode:
  10.187 +                return PREDEC;
  10.188 +            case POSTINCcode:
  10.189 +                return POSTINC;
  10.190 +            case POSTDECcode:
  10.191 +                return POSTDEC;
  10.192 +            default:
  10.193 +                return NO_TAG;
  10.194 +        }
  10.195 +    }
  10.196 +
  10.197 +    /** Maps JCTree.Tag objects to unary operator integer codes
  10.198 +     *  @param tag the JCTree.Tag
  10.199 +     */
  10.200 +    private static int mapTagToUnaryOpCode(Tag tag){
  10.201 +        switch (tag){
  10.202 +            case PREINC:
  10.203 +                return PREINCcode;
  10.204 +            case PREDEC:
  10.205 +                return PREDECcode;
  10.206 +            case POSTINC:
  10.207 +                return POSTINCcode;
  10.208 +            case POSTDEC:
  10.209 +                return POSTDECcode;
  10.210 +            default:
  10.211 +                return -1;
  10.212 +        }
  10.213 +    }
  10.214 +
  10.215      /** Construct definition of an access method.
  10.216       *  @param pos        The source code position of the definition.
  10.217       *  @param vsym       The private or protected symbol.
  10.218 @@ -1259,8 +1297,7 @@
  10.219                  expr = make.Assign(ref, args.head);
  10.220                  break;
  10.221              case PREINCcode: case POSTINCcode: case PREDECcode: case POSTDECcode:
  10.222 -                expr = makeUnary(
  10.223 -                    ((acode1 - PREINCcode) >> 1) + JCTree.PREINC, ref);
  10.224 +                expr = makeUnary(mapUnaryOpCodeToTag(acode1), ref);
  10.225                  break;
  10.226              default:
  10.227                  expr = make.Assignop(
  10.228 @@ -1576,7 +1613,7 @@
  10.229      }
  10.230  
  10.231      private JCExpression makeNonNullCheck(JCExpression expression) {
  10.232 -        return makeBinary(JCTree.NE, expression, makeNull());
  10.233 +        return makeBinary(NE, expression, makeNull());
  10.234      }
  10.235  
  10.236      /** Construct a tree that represents the outer instance
  10.237 @@ -1808,7 +1845,7 @@
  10.238              // $newcache.getClass().getComponentType().getClassLoader() : cl$"
  10.239              JCExpression clvalue =
  10.240                  make.Conditional(
  10.241 -                    makeBinary(JCTree.EQ, make.Ident(clsym), makeNull()),
  10.242 +                    makeBinary(EQ, make.Ident(clsym), makeNull()),
  10.243                      make.Assign(
  10.244                          make.Ident(clsym),
  10.245                          makeCall(
  10.246 @@ -1976,7 +2013,7 @@
  10.247                  writer.xClassName(type).toString().replace('/', '.');
  10.248              Symbol cs = cacheSym(pos, sig);
  10.249              return make_at(pos).Conditional(
  10.250 -                makeBinary(JCTree.EQ, make.Ident(cs), makeNull()),
  10.251 +                makeBinary(EQ, make.Ident(cs), makeNull()),
  10.252                  make.Assign(
  10.253                      make.Ident(cs),
  10.254                      make.App(
  10.255 @@ -2023,7 +2060,7 @@
  10.256                                                              List.<Type>nil());
  10.257              JCClassDecl containerDef = classDef(container);
  10.258              make_at(containerDef.pos());
  10.259 -            JCExpression notStatus = makeUnary(JCTree.NOT, make.App(make.Select(
  10.260 +            JCExpression notStatus = makeUnary(NOT, make.App(make.Select(
  10.261                      classOfType(types.erasure(outermostClass.type),
  10.262                                  containerDef.pos()),
  10.263                      desiredAssertionStatusSym)));
  10.264 @@ -2032,7 +2069,7 @@
  10.265              containerDef.defs = containerDef.defs.prepend(assertDisabledDef);
  10.266          }
  10.267          make_at(pos);
  10.268 -        return makeUnary(JCTree.NOT, make.Ident(assertDisabledSym));
  10.269 +        return makeUnary(NOT, make.Ident(assertDisabledSym));
  10.270      }
  10.271  
  10.272  
  10.273 @@ -2062,9 +2099,9 @@
  10.274      JCTree abstractRval(JCTree rval, Type type, TreeBuilder builder) {
  10.275          rval = TreeInfo.skipParens(rval);
  10.276          switch (rval.getTag()) {
  10.277 -        case JCTree.LITERAL:
  10.278 +        case LITERAL:
  10.279              return builder.build(rval);
  10.280 -        case JCTree.IDENT:
  10.281 +        case IDENT:
  10.282              JCIdent id = (JCIdent) rval;
  10.283              if ((id.sym.flags() & FINAL) != 0 && id.sym.owner.kind == MTH)
  10.284                  return builder.build(rval);
  10.285 @@ -2097,9 +2134,9 @@
  10.286      JCTree abstractLval(JCTree lval, final TreeBuilder builder) {
  10.287          lval = TreeInfo.skipParens(lval);
  10.288          switch (lval.getTag()) {
  10.289 -        case JCTree.IDENT:
  10.290 +        case IDENT:
  10.291              return builder.build(lval);
  10.292 -        case JCTree.SELECT: {
  10.293 +        case SELECT: {
  10.294              final JCFieldAccess s = (JCFieldAccess)lval;
  10.295              JCTree selected = TreeInfo.skipParens(s.selected);
  10.296              Symbol lid = TreeInfo.symbol(s.selected);
  10.297 @@ -2110,7 +2147,7 @@
  10.298                      }
  10.299                  });
  10.300          }
  10.301 -        case JCTree.INDEXED: {
  10.302 +        case INDEXED: {
  10.303              final JCArrayAccess i = (JCArrayAccess)lval;
  10.304              return abstractRval(i.indexed, new TreeBuilder() {
  10.305                      public JCTree build(final JCTree indexed) {
  10.306 @@ -2125,7 +2162,7 @@
  10.307                      }
  10.308                  });
  10.309          }
  10.310 -        case JCTree.TYPECAST: {
  10.311 +        case TYPECAST: {
  10.312              return abstractLval(((JCTypeCast)lval).expr, builder);
  10.313          }
  10.314          }
  10.315 @@ -2345,7 +2382,7 @@
  10.316          for (List<JCTree> defs = tree.defs;
  10.317               defs.nonEmpty();
  10.318               defs=defs.tail) {
  10.319 -            if (defs.head.getTag() == JCTree.VARDEF && (((JCVariableDecl) defs.head).mods.flags & ENUM) != 0) {
  10.320 +            if (defs.head.hasTag(VARDEF) && (((JCVariableDecl) defs.head).mods.flags & ENUM) != 0) {
  10.321                  JCVariableDecl var = (JCVariableDecl)defs.head;
  10.322                  visitEnumConstantDef(var, nextOrdinal++);
  10.323                  values.append(make.QualIdent(var.sym));
  10.324 @@ -2757,9 +2794,9 @@
  10.325                  List.<JCExpression>nil() : List.of(translate(tree.detail));
  10.326              if (!tree.cond.type.isFalse()) {
  10.327                  cond = makeBinary
  10.328 -                    (JCTree.AND,
  10.329 +                    (AND,
  10.330                       cond,
  10.331 -                     makeUnary(JCTree.NOT, tree.cond));
  10.332 +                     makeUnary(NOT, tree.cond));
  10.333              }
  10.334              result =
  10.335                  make.If(cond,
  10.336 @@ -2816,7 +2853,7 @@
  10.337              // first argument.
  10.338              if (c.hasOuterInstance()) {
  10.339                  JCExpression thisArg;
  10.340 -                if (tree.meth.getTag() == JCTree.SELECT) {
  10.341 +                if (tree.meth.hasTag(SELECT)) {
  10.342                      thisArg = attr.
  10.343                          makeNullCheck(translate(((JCFieldAccess) tree.meth).selected));
  10.344                      tree.meth = make.Ident(constructor);
  10.345 @@ -2837,7 +2874,7 @@
  10.346              // If the translated method itself is an Apply tree, we are
  10.347              // seeing an access method invocation. In this case, append
  10.348              // the method arguments to the arguments of the access method.
  10.349 -            if (tree.meth.getTag() == JCTree.APPLY) {
  10.350 +            if (tree.meth.hasTag(APPLY)) {
  10.351                  JCMethodInvocation app = (JCMethodInvocation)tree.meth;
  10.352                  app.args = tree.args.prependList(app.args);
  10.353                  result = app;
  10.354 @@ -2971,7 +3008,7 @@
  10.355          // If translated left hand side is an Apply, we are
  10.356          // seeing an access method invocation. In this case, append
  10.357          // right hand side as last argument of the access method.
  10.358 -        if (tree.lhs.getTag() == JCTree.APPLY) {
  10.359 +        if (tree.lhs.hasTag(APPLY)) {
  10.360              JCMethodInvocation app = (JCMethodInvocation)tree.lhs;
  10.361              app.args = List.of(tree.rhs).prependList(app.args);
  10.362              result = app;
  10.363 @@ -2988,7 +3025,7 @@
  10.364              // (but without recomputing x)
  10.365              JCTree newTree = abstractLval(tree.lhs, new TreeBuilder() {
  10.366                      public JCTree build(final JCTree lhs) {
  10.367 -                        int newTag = tree.getTag() - JCTree.ASGOffset;
  10.368 +                        JCTree.Tag newTag = tree.getTag().noAssignOp();
  10.369                          // Erasure (TransTypes) can change the type of
  10.370                          // tree.lhs.  However, we can still get the
  10.371                          // unerased type of tree.lhs as it is stored
  10.372 @@ -3018,7 +3055,7 @@
  10.373          // If translated left hand side is an Apply, we are
  10.374          // seeing an access method invocation. In this case, append
  10.375          // right hand side as last argument of the access method.
  10.376 -        if (tree.lhs.getTag() == JCTree.APPLY) {
  10.377 +        if (tree.lhs.hasTag(APPLY)) {
  10.378              JCMethodInvocation app = (JCMethodInvocation)tree.lhs;
  10.379              // if operation is a += on strings,
  10.380              // make sure to convert argument to string
  10.381 @@ -3038,13 +3075,13 @@
  10.382          // or
  10.383          // translate to tmp1=lval(e); tmp2=tmp1; (typeof tree)tmp1 OP 1; tmp2
  10.384          // where OP is += or -=
  10.385 -        final boolean cast = TreeInfo.skipParens(tree.arg).getTag() == JCTree.TYPECAST;
  10.386 +        final boolean cast = TreeInfo.skipParens(tree.arg).hasTag(TYPECAST);
  10.387          return abstractLval(tree.arg, new TreeBuilder() {
  10.388                  public JCTree build(final JCTree tmp1) {
  10.389                      return abstractRval(tmp1, tree.arg.type, new TreeBuilder() {
  10.390                              public JCTree build(final JCTree tmp2) {
  10.391 -                                int opcode = (tree.getTag() == JCTree.POSTINC)
  10.392 -                                    ? JCTree.PLUS_ASG : JCTree.MINUS_ASG;
  10.393 +                                JCTree.Tag opcode = (tree.hasTag(POSTINC))
  10.394 +                                    ? PLUS_ASG : MINUS_ASG;
  10.395                                  JCTree lhs = cast
  10.396                                      ? make.TypeCast(tree.arg.type, (JCExpression)tmp1)
  10.397                                      : tmp1;
  10.398 @@ -3059,25 +3096,24 @@
  10.399      }
  10.400  
  10.401      public void visitUnary(JCUnary tree) {
  10.402 -        boolean isUpdateOperator =
  10.403 -            JCTree.PREINC <= tree.getTag() && tree.getTag() <= JCTree.POSTDEC;
  10.404 +        boolean isUpdateOperator = tree.getTag().isIncOrDecUnaryOp();
  10.405          if (isUpdateOperator && !tree.arg.type.isPrimitive()) {
  10.406              switch(tree.getTag()) {
  10.407 -            case JCTree.PREINC:            // ++ e
  10.408 +            case PREINC:            // ++ e
  10.409                      // translate to e += 1
  10.410 -            case JCTree.PREDEC:            // -- e
  10.411 +            case PREDEC:            // -- e
  10.412                      // translate to e -= 1
  10.413                  {
  10.414 -                    int opcode = (tree.getTag() == JCTree.PREINC)
  10.415 -                        ? JCTree.PLUS_ASG : JCTree.MINUS_ASG;
  10.416 +                    JCTree.Tag opcode = (tree.hasTag(PREINC))
  10.417 +                        ? PLUS_ASG : MINUS_ASG;
  10.418                      JCAssignOp newTree = makeAssignop(opcode,
  10.419                                                      tree.arg,
  10.420                                                      make.Literal(1));
  10.421                      result = translate(newTree, tree.type);
  10.422                      return;
  10.423                  }
  10.424 -            case JCTree.POSTINC:           // e ++
  10.425 -            case JCTree.POSTDEC:           // e --
  10.426 +            case POSTINC:           // e ++
  10.427 +            case POSTDEC:           // e --
  10.428                  {
  10.429                      result = translate(lowerBoxedPostop(tree), tree.type);
  10.430                      return;
  10.431 @@ -3088,14 +3124,14 @@
  10.432  
  10.433          tree.arg = boxIfNeeded(translate(tree.arg, tree), tree.type);
  10.434  
  10.435 -        if (tree.getTag() == JCTree.NOT && tree.arg.type.constValue() != null) {
  10.436 +        if (tree.hasTag(NOT) && tree.arg.type.constValue() != null) {
  10.437              tree.type = cfolder.fold1(bool_not, tree.arg.type);
  10.438          }
  10.439  
  10.440          // If translated left hand side is an Apply, we are
  10.441          // seeing an access method invocation. In this case, return
  10.442          // that access method invocation as result.
  10.443 -        if (isUpdateOperator && tree.arg.getTag() == JCTree.APPLY) {
  10.444 +        if (isUpdateOperator && tree.arg.hasTag(APPLY)) {
  10.445              result = tree.arg;
  10.446          } else {
  10.447              result = tree;
  10.448 @@ -3106,7 +3142,7 @@
  10.449          List<Type> formals = tree.operator.type.getParameterTypes();
  10.450          JCTree lhs = tree.lhs = translate(tree.lhs, formals.head);
  10.451          switch (tree.getTag()) {
  10.452 -        case JCTree.OR:
  10.453 +        case OR:
  10.454              if (lhs.type.isTrue()) {
  10.455                  result = lhs;
  10.456                  return;
  10.457 @@ -3116,7 +3152,7 @@
  10.458                  return;
  10.459              }
  10.460              break;
  10.461 -        case JCTree.AND:
  10.462 +        case AND:
  10.463              if (lhs.type.isFalse()) {
  10.464                  result = lhs;
  10.465                  return;
  10.466 @@ -3186,9 +3222,9 @@
  10.467              indexdef.init.type = indexdef.type = syms.intType.constType(0);
  10.468  
  10.469              List<JCStatement> loopinit = List.of(arraycachedef, lencachedef, indexdef);
  10.470 -            JCBinary cond = makeBinary(JCTree.LT, make.Ident(index), make.Ident(lencache));
  10.471 -
  10.472 -            JCExpressionStatement step = make.Exec(makeUnary(JCTree.PREINC, make.Ident(index)));
  10.473 +            JCBinary cond = makeBinary(LT, make.Ident(index), make.Ident(lencache));
  10.474 +
  10.475 +            JCExpressionStatement step = make.Exec(makeUnary(PREINC, make.Ident(index)));
  10.476  
  10.477              Type elemtype = types.elemtype(tree.expr.type);
  10.478              JCExpression loopvarinit = make.Indexed(make.Ident(arraycache),
  10.479 @@ -3592,7 +3628,7 @@
  10.480          // need to special case-access of the form C.super.x
  10.481          // these will always need an access method.
  10.482          boolean qualifiedSuperAccess =
  10.483 -            tree.selected.getTag() == JCTree.SELECT &&
  10.484 +            tree.selected.hasTag(SELECT) &&
  10.485              TreeInfo.name(tree.selected) == names._super;
  10.486          tree.selected = translate(tree.selected);
  10.487          if (tree.name == names._class)
  10.488 @@ -3642,7 +3678,7 @@
  10.489              endPositions = env.toplevel.endPositions;
  10.490              currentClass = null;
  10.491              currentMethodDef = null;
  10.492 -            outermostClassDef = (cdef.getTag() == JCTree.CLASSDEF) ? (JCClassDecl)cdef : null;
  10.493 +            outermostClassDef = (cdef.hasTag(CLASSDEF)) ? (JCClassDecl)cdef : null;
  10.494              outermostMemberDef = null;
  10.495              this.translated = new ListBuffer<JCTree>();
  10.496              classdefs = new HashMap<ClassSymbol,JCClassDecl>();
  10.497 @@ -3838,7 +3874,7 @@
  10.498  
  10.499          JCIdent fLocUsageId = make.Ident(otherVarSym);
  10.500          JCExpression sel = make.Select(fLocUsageId, ordinalSymbol);
  10.501 -        JCBinary bin = makeBinary(JCTree.MINUS, id1, sel);
  10.502 +        JCBinary bin = makeBinary(MINUS, id1, sel);
  10.503          JCReturn ret = make.Return(bin);
  10.504          blockStatements.append(ret);
  10.505          JCMethodDecl compareToMethod = make.MethodDef((MethodSymbol)compareToSym,

    11.1 --- a/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Sat Nov 05 00:02:33 2011 -0700
    11.2 +++ b/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Tue Nov 08 11:51:05 2011 -0800
    11.3 @@ -40,8 +40,10 @@
    11.4  import com.sun.tools.javac.tree.JCTree.*;
    11.5  
    11.6  import static com.sun.tools.javac.code.Flags.*;
    11.7 +import static com.sun.tools.javac.code.Flags.ANNOTATION;
    11.8  import static com.sun.tools.javac.code.Kinds.*;
    11.9  import static com.sun.tools.javac.code.TypeTags.*;
   11.10 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   11.11  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
   11.12  
   11.13  /** This is the second phase of Enter, in which classes are completed
   11.14 @@ -644,7 +646,7 @@
   11.15          tree.sym = v;
   11.16          if (tree.init != null) {
   11.17              v.flags_field |= HASINIT;
   11.18 -            if ((v.flags_field & FINAL) != 0 && tree.init.getTag() != JCTree.NEWCLASS) {
   11.19 +            if ((v.flags_field & FINAL) != 0 && !tree.init.hasTag(NEWCLASS)) {
   11.20                  Env<AttrContext> initEnv = getInitEnv(tree, env);
   11.21                  initEnv.info.enclVar = v;
   11.22                  v.setLazyConstValue(initEnv(tree, initEnv), attr, tree.init);
   11.23 @@ -868,7 +870,7 @@
   11.24              // If this is a toplevel-class, make sure any preceding import
   11.25              // clauses have been seen.
   11.26              if (c.owner.kind == PCK) {
   11.27 -                memberEnter(env.toplevel, env.enclosing(JCTree.TOPLEVEL));
   11.28 +                memberEnter(env.toplevel, env.enclosing(TOPLEVEL));
   11.29                  todo.append(env);
   11.30              }
   11.31  

    12.1 --- a/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Sat Nov 05 00:02:33 2011 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Tue Nov 08 11:51:05 2011 -0800
    12.3 @@ -49,9 +49,12 @@
    12.4  import javax.lang.model.element.ElementVisitor;
    12.5  
    12.6  import static com.sun.tools.javac.code.Flags.*;
    12.7 +import static com.sun.tools.javac.code.Flags.BLOCK;
    12.8  import static com.sun.tools.javac.code.Kinds.*;
    12.9 +import static com.sun.tools.javac.code.Kinds.ERRONEOUS;
   12.10  import static com.sun.tools.javac.code.TypeTags.*;
   12.11  import static com.sun.tools.javac.comp.Resolve.MethodResolutionPhase.*;
   12.12 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   12.13  
   12.14  /** Helper class for name resolution, used mostly by the attribution phase.
   12.15   *
   12.16 @@ -1269,7 +1272,7 @@
   12.17                  staticOnly = true;
   12.18          }
   12.19  
   12.20 -        if (env.tree.getTag() != JCTree.IMPORT) {
   12.21 +        if (!env.tree.hasTag(IMPORT)) {
   12.22              sym = findGlobalType(env, env.toplevel.namedImportScope, name);
   12.23              if (sym.exists()) return sym;
   12.24              else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
   12.25 @@ -1796,7 +1799,7 @@
   12.26       *  @param env       The environment current at the operation.
   12.27       *  @param argtypes  The types of the operands.
   12.28       */
   12.29 -    Symbol resolveOperator(DiagnosticPosition pos, int optag,
   12.30 +    Symbol resolveOperator(DiagnosticPosition pos, JCTree.Tag optag,
   12.31                             Env<AttrContext> env, List<Type> argtypes) {
   12.32          startResolution();
   12.33          Name name = treeinfo.operatorName(optag);
   12.34 @@ -1815,7 +1818,7 @@
   12.35       *  @param env       The environment current at the operation.
   12.36       *  @param arg       The type of the operand.
   12.37       */
   12.38 -    Symbol resolveUnaryOperator(DiagnosticPosition pos, int optag, Env<AttrContext> env, Type arg) {
   12.39 +    Symbol resolveUnaryOperator(DiagnosticPosition pos, JCTree.Tag optag, Env<AttrContext> env, Type arg) {
   12.40          return resolveOperator(pos, optag, env, List.of(arg));
   12.41      }
   12.42  
   12.43 @@ -1827,7 +1830,7 @@
   12.44       *  @param right     The types of the right operand.
   12.45       */
   12.46      Symbol resolveBinaryOperator(DiagnosticPosition pos,
   12.47 -                                 int optag,
   12.48 +                                 JCTree.Tag optag,
   12.49                                   Env<AttrContext> env,
   12.50                                   Type left,
   12.51                                   Type right) {

    13.1 --- a/src/share/classes/com/sun/tools/javac/jvm/CRTable.java	Sat Nov 05 00:02:33 2011 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/CRTable.java	Tue Nov 08 11:51:05 2011 -0800
    13.3 @@ -532,7 +532,7 @@
    13.4           */
    13.5          public int endPos(JCTree tree) {
    13.6              if (tree == null) return Position.NOPOS;
    13.7 -            if (tree.getTag() == JCTree.BLOCK)
    13.8 +            if (tree.hasTag(JCTree.Tag.BLOCK))
    13.9                  return ((JCBlock) tree).endpos;
   13.10              Integer endpos = endPositions.get(tree);
   13.11              if (endpos != null)

    14.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Sat Nov 05 00:02:33 2011 -0700
    14.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Tue Nov 08 11:51:05 2011 -0800
    14.3 @@ -47,6 +47,8 @@
    14.4  import static com.sun.tools.javac.jvm.ByteCodes.*;
    14.5  import static com.sun.tools.javac.jvm.CRTFlags.*;
    14.6  import static com.sun.tools.javac.main.OptionName.*;
    14.7 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    14.8 +import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
    14.9  
   14.10  /** This pass maps flat Java (i.e. without inner classes) to bytecodes.
   14.11   *
   14.12 @@ -433,7 +435,7 @@
   14.13       */
   14.14      boolean hasFinally(JCTree target, Env<GenContext> env) {
   14.15          while (env.tree != target) {
   14.16 -            if (env.tree.getTag() == JCTree.TRY && env.info.finalize.hasFinalizer())
   14.17 +            if (env.tree.hasTag(TRY) && env.info.finalize.hasFinalizer())
   14.18                  return true;
   14.19              env = env.next;
   14.20          }
   14.21 @@ -460,17 +462,17 @@
   14.22          for (List<JCTree> l = defs; l.nonEmpty(); l = l.tail) {
   14.23              JCTree def = l.head;
   14.24              switch (def.getTag()) {
   14.25 -            case JCTree.BLOCK:
   14.26 +            case BLOCK:
   14.27                  JCBlock block = (JCBlock)def;
   14.28                  if ((block.flags & STATIC) != 0)
   14.29                      clinitCode.append(block);
   14.30                  else
   14.31                      initCode.append(block);
   14.32                  break;
   14.33 -            case JCTree.METHODDEF:
   14.34 +            case METHODDEF:
   14.35                  methodDefs.append(def);
   14.36                  break;
   14.37 -            case JCTree.VARDEF:
   14.38 +            case VARDEF:
   14.39                  JCVariableDecl vdef = (JCVariableDecl) def;
   14.40                  VarSymbol sym = vdef.sym;
   14.41                  checkDimension(vdef.pos(), sym.type);
   14.42 @@ -707,7 +709,7 @@
   14.43          }
   14.44          int startpc = code.curPc();
   14.45          genStat(tree, env);
   14.46 -        if (tree.getTag() == JCTree.BLOCK) crtFlags |= CRT_BLOCK;
   14.47 +        if (tree.hasTag(BLOCK)) crtFlags |= CRT_BLOCK;
   14.48          code.crt.put(tree, crtFlags, startpc, code.curPc());
   14.49      }
   14.50  
   14.51 @@ -717,7 +719,7 @@
   14.52          if (code.isAlive()) {
   14.53              code.statBegin(tree.pos);
   14.54              genDef(tree, env);
   14.55 -        } else if (env.info.isSwitch && tree.getTag() == JCTree.VARDEF) {
   14.56 +        } else if (env.info.isSwitch && tree.hasTag(VARDEF)) {
   14.57              // variables whose declarations are in a switch
   14.58              // can be used even if the decl is unreachable.
   14.59              code.newLocal(((JCVariableDecl) tree).sym);
   14.60 @@ -784,7 +786,7 @@
   14.61       */
   14.62      public CondItem genCond(JCTree _tree, boolean markBranches) {
   14.63          JCTree inner_tree = TreeInfo.skipParens(_tree);
   14.64 -        if (inner_tree.getTag() == JCTree.CONDEXPR) {
   14.65 +        if (inner_tree.hasTag(CONDEXPR)) {
   14.66              JCConditional tree = (JCConditional)inner_tree;
   14.67              CondItem cond = genCond(tree.cond, CRT_FLOW_CONTROLLER);
   14.68              if (cond.isTrue()) {
   14.69 @@ -1033,7 +1035,7 @@
   14.70          Env<GenContext> localEnv = env.dup(tree, new GenContext());
   14.71          genStats(tree.stats, localEnv);
   14.72          // End the scope of all block-local variables in variable info.
   14.73 -        if (env.tree.getTag() != JCTree.METHODDEF) {
   14.74 +        if (!env.tree.hasTag(METHODDEF)) {
   14.75              code.statBegin(tree.endpos);
   14.76              code.endScopes(limit);
   14.77              code.pendingStatPos = Position.NOPOS;
   14.78 @@ -1628,11 +1630,11 @@
   14.79          // Optimize x++ to ++x and x-- to --x.
   14.80          JCExpression e = tree.expr;
   14.81          switch (e.getTag()) {
   14.82 -            case JCTree.POSTINC:
   14.83 -                ((JCUnary) e).setTag(JCTree.PREINC);
   14.84 +            case POSTINC:
   14.85 +                ((JCUnary) e).setTag(PREINC);
   14.86                  break;
   14.87 -            case JCTree.POSTDEC:
   14.88 -                ((JCUnary) e).setTag(JCTree.PREDEC);
   14.89 +            case POSTDEC:
   14.90 +                ((JCUnary) e).setTag(PREDEC);
   14.91                  break;
   14.92          }
   14.93          genExpr(tree.expr, tree.expr.type).drop();
   14.94 @@ -1819,13 +1821,13 @@
   14.95              // If we have an increment of -32768 to +32767 of a local
   14.96              // int variable we can use an incr instruction instead of
   14.97              // proceeding further.
   14.98 -            if ((tree.getTag() == JCTree.PLUS_ASG || tree.getTag() == JCTree.MINUS_ASG) &&
   14.99 +            if ((tree.hasTag(PLUS_ASG) || tree.hasTag(MINUS_ASG)) &&
  14.100                  l instanceof LocalItem &&
  14.101                  tree.lhs.type.tag <= INT &&
  14.102                  tree.rhs.type.tag <= INT &&
  14.103                  tree.rhs.type.constValue() != null) {
  14.104                  int ival = ((Number) tree.rhs.type.constValue()).intValue();
  14.105 -                if (tree.getTag() == JCTree.MINUS_ASG) ival = -ival;
  14.106 +                if (tree.hasTag(MINUS_ASG)) ival = -ival;
  14.107                  ((LocalItem)l).incr(ival);
  14.108                  result = l;
  14.109                  return;
  14.110 @@ -1841,29 +1843,29 @@
  14.111  
  14.112      public void visitUnary(JCUnary tree) {
  14.113          OperatorSymbol operator = (OperatorSymbol)tree.operator;
  14.114 -        if (tree.getTag() == JCTree.NOT) {
  14.115 +        if (tree.hasTag(NOT)) {
  14.116              CondItem od = genCond(tree.arg, false);
  14.117              result = od.negate();
  14.118          } else {
  14.119              Item od = genExpr(tree.arg, operator.type.getParameterTypes().head);
  14.120              switch (tree.getTag()) {
  14.121 -            case JCTree.POS:
  14.122 +            case POS:
  14.123                  result = od.load();
  14.124                  break;
  14.125 -            case JCTree.NEG:
  14.126 +            case NEG:
  14.127                  result = od.load();
  14.128                  code.emitop0(operator.opcode);
  14.129                  break;
  14.130 -            case JCTree.COMPL:
  14.131 +            case COMPL:
  14.132                  result = od.load();
  14.133                  emitMinusOne(od.typecode);
  14.134                  code.emitop0(operator.opcode);
  14.135                  break;
  14.136 -            case JCTree.PREINC: case JCTree.PREDEC:
  14.137 +            case PREINC: case PREDEC:
  14.138                  od.duplicate();
  14.139                  if (od instanceof LocalItem &&
  14.140                      (operator.opcode == iadd || operator.opcode == isub)) {
  14.141 -                    ((LocalItem)od).incr(tree.getTag() == JCTree.PREINC ? 1 : -1);
  14.142 +                    ((LocalItem)od).incr(tree.hasTag(PREINC) ? 1 : -1);
  14.143                      result = od;
  14.144                  } else {
  14.145                      od.load();
  14.146 @@ -1877,12 +1879,12 @@
  14.147                      result = items.makeAssignItem(od);
  14.148                  }
  14.149                  break;
  14.150 -            case JCTree.POSTINC: case JCTree.POSTDEC:
  14.151 +            case POSTINC: case POSTDEC:
  14.152                  od.duplicate();
  14.153                  if (od instanceof LocalItem &&
  14.154                      (operator.opcode == iadd || operator.opcode == isub)) {
  14.155                      Item res = od.load();
  14.156 -                    ((LocalItem)od).incr(tree.getTag() == JCTree.POSTINC ? 1 : -1);
  14.157 +                    ((LocalItem)od).incr(tree.hasTag(POSTINC) ? 1 : -1);
  14.158                      result = res;
  14.159                  } else {
  14.160                      Item res = od.load();
  14.161 @@ -1898,7 +1900,7 @@
  14.162                      result = res;
  14.163                  }
  14.164                  break;
  14.165 -            case JCTree.NULLCHK:
  14.166 +            case NULLCHK:
  14.167                  result = od.load();
  14.168                  code.emitop0(dup);
  14.169                  genNullCheck(tree.pos());
  14.170 @@ -1926,7 +1928,7 @@
  14.171              // Convert buffer to string.
  14.172              bufferToString(tree.pos());
  14.173              result = items.makeStackItem(syms.stringType);
  14.174 -        } else if (tree.getTag() == JCTree.AND) {
  14.175 +        } else if (tree.hasTag(AND)) {
  14.176              CondItem lcond = genCond(tree.lhs, CRT_FLOW_CONTROLLER);
  14.177              if (!lcond.isFalse()) {
  14.178                  Chain falseJumps = lcond.jumpFalse();
  14.179 @@ -1940,7 +1942,7 @@
  14.180              } else {
  14.181                  result = lcond;
  14.182              }
  14.183 -        } else if (tree.getTag() == JCTree.OR) {
  14.184 +        } else if (tree.hasTag(OR)) {
  14.185              CondItem lcond = genCond(tree.lhs, CRT_FLOW_CONTROLLER);
  14.186              if (!lcond.isTrue()) {
  14.187                  Chain trueJumps = lcond.jumpTrue();
  14.188 @@ -1997,7 +1999,7 @@
  14.189           */
  14.190          void appendStrings(JCTree tree) {
  14.191              tree = TreeInfo.skipParens(tree);
  14.192 -            if (tree.getTag() == JCTree.PLUS && tree.type.constValue() == null) {
  14.193 +            if (tree.hasTag(PLUS) && tree.type.constValue() == null) {
  14.194                  JCBinary op = (JCBinary) tree;
  14.195                  if (op.operator.kind == MTH &&
  14.196                      ((OperatorSymbol) op.operator).opcode == string_add) {
  14.197 @@ -2240,7 +2242,7 @@
  14.198              if (nerrs != 0) {
  14.199                  // if errors, discard code
  14.200                  for (List<JCTree> l = cdef.defs; l.nonEmpty(); l = l.tail) {
  14.201 -                    if (l.head.getTag() == JCTree.METHODDEF)
  14.202 +                    if (l.head.hasTag(METHODDEF))
  14.203                          ((JCMethodDecl) l.head).sym.code = null;
  14.204                  }
  14.205              }

    15.1 --- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Sat Nov 05 00:02:33 2011 -0700
    15.2 +++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Tue Nov 08 11:51:05 2011 -0800
    15.3 @@ -1506,20 +1506,20 @@
    15.4                      for (List<JCTree> it = tree.defs; it.tail != null; it = it.tail) {
    15.5                          JCTree t = it.head;
    15.6                          switch (t.getTag()) {
    15.7 -                        case JCTree.CLASSDEF:
    15.8 +                        case CLASSDEF:
    15.9                              if (isInterface ||
   15.10                                  (((JCClassDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
   15.11                                  (((JCClassDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCClassDecl) t).sym.packge().getQualifiedName() == names.java_lang)
   15.12                                  newdefs.append(t);
   15.13                              break;
   15.14 -                        case JCTree.METHODDEF:
   15.15 +                        case METHODDEF:
   15.16                              if (isInterface ||
   15.17                                  (((JCMethodDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
   15.18                                  ((JCMethodDecl) t).sym.name == names.init ||
   15.19                                  (((JCMethodDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCMethodDecl) t).sym.packge().getQualifiedName() == names.java_lang)
   15.20                                  newdefs.append(t);
   15.21                              break;
   15.22 -                        case JCTree.VARDEF:
   15.23 +                        case VARDEF:
   15.24                              if (isInterface || (((JCVariableDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
   15.25                                  (((JCVariableDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCVariableDecl) t).sym.packge().getQualifiedName() == names.java_lang)
   15.26                                  newdefs.append(t);

    16.1 --- a/src/share/classes/com/sun/tools/javac/model/JavacElements.java	Sat Nov 05 00:02:33 2011 -0700
    16.2 +++ b/src/share/classes/com/sun/tools/javac/model/JavacElements.java	Tue Nov 08 11:51:05 2011 -0800
    16.3 @@ -1,5 +1,5 @@
    16.4  /*
    16.5 - * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
    16.6 + * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
    16.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.8   *
    16.9   * This code is free software; you can redistribute it and/or modify it
   16.10 @@ -48,6 +48,7 @@
   16.11  import com.sun.tools.javac.util.*;
   16.12  import com.sun.tools.javac.util.Name;
   16.13  
   16.14 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   16.15  import static javax.lang.model.util.ElementFilter.methodsIn;
   16.16  
   16.17  /**
   16.18 @@ -288,7 +289,7 @@
   16.19                  }
   16.20              }
   16.21              public void visitArray(Attribute.Array array) {
   16.22 -                if (tree.getTag() == JCTree.NEWARRAY &&
   16.23 +                if (tree.hasTag(NEWARRAY) &&
   16.24                          types.elemtype(array.type).tsym == findme.type.tsym) {
   16.25                      List<JCExpression> elems = ((JCNewArray) tree).elems;
   16.26                      for (Attribute value : array.values) {
   16.27 @@ -327,7 +328,7 @@
   16.28                      scan(t.args);
   16.29              }
   16.30              public void visitAssign(JCAssign t) {
   16.31 -                if (t.lhs.getTag() == JCTree.IDENT) {
   16.32 +                if (t.lhs.hasTag(IDENT)) {
   16.33                      JCIdent ident = (JCIdent) t.lhs;
   16.34                      if (ident.sym == sym)
   16.35                          result = t.rhs;

    17.1 --- a/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Sat Nov 05 00:02:33 2011 -0700
    17.2 +++ b/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Tue Nov 08 11:51:05 2011 -0800
    17.3 @@ -37,8 +37,16 @@
    17.4  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
    17.5  import com.sun.tools.javac.util.List;
    17.6  
    17.7 +import static com.sun.tools.javac.parser.Tokens.TokenKind.*;
    17.8 +import static com.sun.tools.javac.parser.Tokens.TokenKind.ASSERT;
    17.9 +import static com.sun.tools.javac.parser.Tokens.TokenKind.CASE;
   17.10 +import static com.sun.tools.javac.parser.Tokens.TokenKind.CATCH;
   17.11 +import static com.sun.tools.javac.parser.Tokens.TokenKind.EQ;
   17.12 +import static com.sun.tools.javac.parser.Tokens.TokenKind.GT;
   17.13 +import static com.sun.tools.javac.parser.Tokens.TokenKind.IMPORT;
   17.14 +import static com.sun.tools.javac.parser.Tokens.TokenKind.LT;
   17.15  import static com.sun.tools.javac.util.ListBuffer.lb;
   17.16 -import static com.sun.tools.javac.parser.Tokens.TokenKind.*;
   17.17 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
   17.18  
   17.19  /** The parser maps a token sequence into an abstract syntax
   17.20   *  tree. It operates by recursive descent, with code derived
   17.21 @@ -758,7 +766,7 @@
   17.22          Assert.check(top == 0);
   17.23          t = odStack[0];
   17.24  
   17.25 -        if (t.getTag() == JCTree.PLUS) {
   17.26 +        if (t.hasTag(JCTree.Tag.PLUS)) {
   17.27              StringBuffer buf = foldStrings(t);
   17.28              if (buf != null) {
   17.29                  t = toP(F.at(startPos).Literal(TypeTags.CLASS, buf.toString()));
   17.30 @@ -791,7 +799,7 @@
   17.31                  return null;
   17.32              List<String> buf = List.nil();
   17.33              while (true) {
   17.34 -                if (tree.getTag() == JCTree.LITERAL) {
   17.35 +                if (tree.hasTag(LITERAL)) {
   17.36                      JCLiteral lit = (JCLiteral) tree;
   17.37                      if (lit.typetag == TypeTags.CLASS) {
   17.38                          StringBuffer sbuf =
   17.39 @@ -802,9 +810,9 @@
   17.40                          }
   17.41                          return sbuf;
   17.42                      }
   17.43 -                } else if (tree.getTag() == JCTree.PLUS) {
   17.44 +                } else if (tree.hasTag(JCTree.Tag.PLUS)) {
   17.45                      JCBinary op = (JCBinary)tree;
   17.46 -                    if (op.rhs.getTag() == JCTree.LITERAL) {
   17.47 +                    if (op.rhs.hasTag(LITERAL)) {
   17.48                          JCLiteral lit = (JCLiteral) op.rhs;
   17.49                          if (lit.typetag == TypeTags.CLASS) {
   17.50                              buf = buf.prepend((String) lit.value);
   17.51 @@ -900,7 +908,7 @@
   17.52                  t = term3();
   17.53                  if ((mode & TYPE) != 0 && token.kind == LT) {
   17.54                      // Could be a cast to a parameterized type
   17.55 -                    int op = JCTree.LT;
   17.56 +                    JCTree.Tag op = JCTree.Tag.LT;
   17.57                      int pos1 = token.pos;
   17.58                      nextToken();
   17.59                      mode &= (EXPR | TYPE);
   17.60 @@ -1154,7 +1162,7 @@
   17.61          while ((token.kind == PLUSPLUS || token.kind == SUBSUB) && (mode & EXPR) != 0) {
   17.62              mode = EXPR;
   17.63              t = to(F.at(token.pos).Unary(
   17.64 -                  token.kind == PLUSPLUS ? JCTree.POSTINC : JCTree.POSTDEC, t));
   17.65 +                  token.kind == PLUSPLUS ? POSTINC : POSTDEC, t));
   17.66              nextToken();
   17.67          }
   17.68          return toP(t);
   17.69 @@ -1627,7 +1635,7 @@
   17.70              default:
   17.71                  Token prevToken = token;
   17.72                  JCExpression t = term(EXPR | TYPE);
   17.73 -                if (token.kind == COLON && t.getTag() == JCTree.IDENT) {
   17.74 +                if (token.kind == COLON && t.hasTag(IDENT)) {
   17.75                      nextToken();
   17.76                      JCStatement stat = parseStatement();
   17.77                      stats.append(F.at(pos).Labelled(prevToken.name(), stat));
   17.78 @@ -1702,7 +1710,7 @@
   17.79              accept(LPAREN);
   17.80              List<JCStatement> inits = token.kind == SEMI ? List.<JCStatement>nil() : forInit();
   17.81              if (inits.length() == 1 &&
   17.82 -                inits.head.getTag() == JCTree.VARDEF &&
   17.83 +                inits.head.hasTag(VARDEF) &&
   17.84                  ((JCVariableDecl) inits.head).init == null &&
   17.85                  token.kind == COLON) {
   17.86                  checkForeach();
   17.87 @@ -1835,7 +1843,7 @@
   17.88          default:
   17.89              Token prevToken = token;
   17.90              JCExpression expr = parseExpression();
   17.91 -            if (token.kind == COLON && expr.getTag() == JCTree.IDENT) {
   17.92 +            if (token.kind == COLON && expr.hasTag(IDENT)) {
   17.93                  nextToken();
   17.94                  JCStatement stat = parseStatement();
   17.95                  return F.at(pos).Labelled(prevToken.name(), stat);
   17.96 @@ -2088,7 +2096,7 @@
   17.97          if (token.kind == IDENTIFIER) {
   17.98              mode = EXPR;
   17.99              JCExpression t1 = term1();
  17.100 -            if (t1.getTag() == JCTree.IDENT && token.kind == EQ) {
  17.101 +            if (t1.hasTag(IDENT) && token.kind == EQ) {
  17.102                  int pos = token.pos;
  17.103                  accept(EQ);
  17.104                  JCExpression v = annotationValue();
  17.105 @@ -2618,7 +2626,7 @@
  17.106                  } else {
  17.107                      type = parseType();
  17.108                  }
  17.109 -                if (token.kind == LPAREN && !isInterface && type.getTag() == JCTree.IDENT) {
  17.110 +                if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) {
  17.111                      if (isInterface || tk.name() != className)
  17.112                          error(pos, "invalid.meth.decl.ret.type.req");
  17.113                      return List.of(methodDeclaratorRest(
  17.114 @@ -2815,15 +2823,15 @@
  17.115       */
  17.116      protected JCExpression checkExprStat(JCExpression t) {
  17.117          switch(t.getTag()) {
  17.118 -        case JCTree.PREINC: case JCTree.PREDEC:
  17.119 -        case JCTree.POSTINC: case JCTree.POSTDEC:
  17.120 -        case JCTree.ASSIGN:
  17.121 -        case JCTree.BITOR_ASG: case JCTree.BITXOR_ASG: case JCTree.BITAND_ASG:
  17.122 -        case JCTree.SL_ASG: case JCTree.SR_ASG: case JCTree.USR_ASG:
  17.123 -        case JCTree.PLUS_ASG: case JCTree.MINUS_ASG:
  17.124 -        case JCTree.MUL_ASG: case JCTree.DIV_ASG: case JCTree.MOD_ASG:
  17.125 -        case JCTree.APPLY: case JCTree.NEWCLASS:
  17.126 -        case JCTree.ERRONEOUS:
  17.127 +        case PREINC: case PREDEC:
  17.128 +        case POSTINC: case POSTDEC:
  17.129 +        case ASSIGN:
  17.130 +        case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
  17.131 +        case SL_ASG: case SR_ASG: case USR_ASG:
  17.132 +        case PLUS_ASG: case MINUS_ASG:
  17.133 +        case MUL_ASG: case DIV_ASG: case MOD_ASG:
  17.134 +        case APPLY: case NEWCLASS:
  17.135 +        case ERRONEOUS:
  17.136              return t;
  17.137          default:
  17.138              JCExpression ret = F.at(t.pos).Erroneous(List.<JCTree>of(t));
  17.139 @@ -2836,8 +2844,8 @@
  17.140       *  -1 if token is not a binary operator. @see TreeInfo.opPrec
  17.141       */
  17.142      static int prec(TokenKind token) {
  17.143 -        int oc = optag(token);
  17.144 -        return (oc >= 0) ? TreeInfo.opPrec(oc) : -1;
  17.145 +        JCTree.Tag oc = optag(token);
  17.146 +        return (oc != NO_TAG) ? TreeInfo.opPrec(oc) : -1;
  17.147      }
  17.148  
  17.149      /**
  17.150 @@ -2853,96 +2861,96 @@
  17.151      }
  17.152  
  17.153      /** Return operation tag of binary operator represented by token,
  17.154 -     *  -1 if token is not a binary operator.
  17.155 +     *  No_TAG if token is not a binary operator.
  17.156       */
  17.157 -    static int optag(TokenKind token) {
  17.158 +    static JCTree.Tag optag(TokenKind token) {
  17.159          switch (token) {
  17.160          case BARBAR:
  17.161 -            return JCTree.OR;
  17.162 +            return OR;
  17.163          case AMPAMP:
  17.164 -            return JCTree.AND;
  17.165 +            return AND;
  17.166          case BAR:
  17.167 -            return JCTree.BITOR;
  17.168 +            return BITOR;
  17.169          case BAREQ:
  17.170 -            return JCTree.BITOR_ASG;
  17.171 +            return BITOR_ASG;
  17.172          case CARET:
  17.173 -            return JCTree.BITXOR;
  17.174 +            return BITXOR;
  17.175          case CARETEQ:
  17.176 -            return JCTree.BITXOR_ASG;
  17.177 +            return BITXOR_ASG;
  17.178          case AMP:
  17.179 -            return JCTree.BITAND;
  17.180 +            return BITAND;
  17.181          case AMPEQ:
  17.182 -            return JCTree.BITAND_ASG;
  17.183 +            return BITAND_ASG;
  17.184          case EQEQ:
  17.185 -            return JCTree.EQ;
  17.186 +            return JCTree.Tag.EQ;
  17.187          case BANGEQ:
  17.188 -            return JCTree.NE;
  17.189 +            return NE;
  17.190          case LT:
  17.191 -            return JCTree.LT;
  17.192 +            return JCTree.Tag.LT;
  17.193          case GT:
  17.194 -            return JCTree.GT;
  17.195 +            return JCTree.Tag.GT;
  17.196          case LTEQ:
  17.197 -            return JCTree.LE;
  17.198 +            return LE;
  17.199          case GTEQ:
  17.200 -            return JCTree.GE;
  17.201 +            return GE;
  17.202          case LTLT:
  17.203 -            return JCTree.SL;
  17.204 +            return SL;
  17.205          case LTLTEQ:
  17.206 -            return JCTree.SL_ASG;
  17.207 +            return SL_ASG;
  17.208          case GTGT:
  17.209 -            return JCTree.SR;
  17.210 +            return SR;
  17.211          case GTGTEQ:
  17.212 -            return JCTree.SR_ASG;
  17.213 +            return SR_ASG;
  17.214          case GTGTGT:
  17.215 -            return JCTree.USR;
  17.216 +            return USR;
  17.217          case GTGTGTEQ:
  17.218 -            return JCTree.USR_ASG;
  17.219 +            return USR_ASG;
  17.220          case PLUS:
  17.221 -            return JCTree.PLUS;
  17.222 +            return JCTree.Tag.PLUS;
  17.223          case PLUSEQ:
  17.224 -            return JCTree.PLUS_ASG;
  17.225 +            return PLUS_ASG;
  17.226          case SUB:
  17.227 -            return JCTree.MINUS;
  17.228 +            return MINUS;
  17.229          case SUBEQ:
  17.230 -            return JCTree.MINUS_ASG;
  17.231 +            return MINUS_ASG;
  17.232          case STAR:
  17.233 -            return JCTree.MUL;
  17.234 +            return MUL;
  17.235          case STAREQ:
  17.236 -            return JCTree.MUL_ASG;
  17.237 +            return MUL_ASG;
  17.238          case SLASH:
  17.239 -            return JCTree.DIV;
  17.240 +            return DIV;
  17.241          case SLASHEQ:
  17.242 -            return JCTree.DIV_ASG;
  17.243 +            return DIV_ASG;
  17.244          case PERCENT:
  17.245 -            return JCTree.MOD;
  17.246 +            return MOD;
  17.247          case PERCENTEQ:
  17.248 -            return JCTree.MOD_ASG;
  17.249 +            return MOD_ASG;
  17.250          case INSTANCEOF:
  17.251 -            return JCTree.TYPETEST;
  17.252 +            return TYPETEST;
  17.253          default:
  17.254 -            return -1;
  17.255 +            return NO_TAG;
  17.256          }
  17.257      }
  17.258  
  17.259      /** Return operation tag of unary operator represented by token,
  17.260 -     *  -1 if token is not a binary operator.
  17.261 +     *  No_TAG if token is not a binary operator.
  17.262       */
  17.263 -    static int unoptag(TokenKind token) {
  17.264 +    static JCTree.Tag unoptag(TokenKind token) {
  17.265          switch (token) {
  17.266          case PLUS:
  17.267 -            return JCTree.POS;
  17.268 +            return POS;
  17.269          case SUB:
  17.270 -            return JCTree.NEG;
  17.271 +            return NEG;
  17.272          case BANG:
  17.273 -            return JCTree.NOT;
  17.274 +            return NOT;
  17.275          case TILDE:
  17.276 -            return JCTree.COMPL;
  17.277 +            return COMPL;
  17.278          case PLUSPLUS:
  17.279 -            return JCTree.PREINC;
  17.280 +            return PREINC;
  17.281          case SUBSUB:
  17.282 -            return JCTree.PREDEC;
  17.283 +            return PREDEC;
  17.284          default:
  17.285 -            return -1;
  17.286 +            return NO_TAG;
  17.287          }
  17.288      }
  17.289  

    18.1 --- a/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Sat Nov 05 00:02:33 2011 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java	Tue Nov 08 11:51:05 2011 -0800
    18.3 @@ -1222,7 +1222,7 @@
    18.4          List<ClassSymbol> classes = List.nil();
    18.5          for (JCCompilationUnit unit : units) {
    18.6              for (JCTree node : unit.defs) {
    18.7 -                if (node.getTag() == JCTree.CLASSDEF) {
    18.8 +                if (node.hasTag(JCTree.Tag.CLASSDEF)) {
    18.9                      ClassSymbol sym = ((JCClassDecl) node).sym;
   18.10                      Assert.checkNonNull(sym);
   18.11                      classes = classes.prepend(sym);

    19.1 --- a/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Sat Nov 05 00:02:33 2011 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Tue Nov 08 11:51:05 2011 -0800
    19.3 @@ -42,6 +42,7 @@
    19.4  import com.sun.source.tree.*;
    19.5  
    19.6  import static com.sun.tools.javac.code.BoundKind.*;
    19.7 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    19.8  
    19.9  /**
   19.10   * Root class for abstract syntax tree nodes. It provides definitions
   19.11 @@ -79,253 +80,289 @@
   19.12  public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
   19.13  
   19.14      /* Tree tag values, identifying kinds of trees */
   19.15 +    public enum Tag{
   19.16 +        /** For methods that return an invalid tag if a given condition is not met
   19.17 +         */
   19.18 +        NO_TAG,
   19.19  
   19.20 -    /** Toplevel nodes, of type TopLevel, representing entire source files.
   19.21 -     */
   19.22 -    public static final int  TOPLEVEL = 1;
   19.23 +        /** Toplevel nodes, of type TopLevel, representing entire source files.
   19.24 +        */
   19.25 +        TOPLEVEL,
   19.26  
   19.27 -    /** Import clauses, of type Import.
   19.28 -     */
   19.29 -    public static final int IMPORT = TOPLEVEL + 1;
   19.30 +        /** Import clauses, of type Import.
   19.31 +         */
   19.32 +        IMPORT,
   19.33  
   19.34 -    /** Class definitions, of type ClassDef.
   19.35 -     */
   19.36 -    public static final int CLASSDEF = IMPORT + 1;
   19.37 +        /** Class definitions, of type ClassDef.
   19.38 +         */
   19.39 +        CLASSDEF,
   19.40  
   19.41 -    /** Method definitions, of type MethodDef.
   19.42 -     */
   19.43 -    public static final int METHODDEF = CLASSDEF + 1;
   19.44 +        /** Method definitions, of type MethodDef.
   19.45 +         */
   19.46 +        METHODDEF,
   19.47  
   19.48 -    /** Variable definitions, of type VarDef.
   19.49 -     */
   19.50 -    public static final int VARDEF = METHODDEF + 1;
   19.51 +        /** Variable definitions, of type VarDef.
   19.52 +         */
   19.53 +        VARDEF,
   19.54  
   19.55 -    /** The no-op statement ";", of type Skip
   19.56 -     */
   19.57 -    public static final int SKIP = VARDEF + 1;
   19.58 +        /** The no-op statement ";", of type Skip
   19.59 +         */
   19.60 +        SKIP,
   19.61  
   19.62 -    /** Blocks, of type Block.
   19.63 -     */
   19.64 -    public static final int BLOCK = SKIP + 1;
   19.65 +        /** Blocks, of type Block.
   19.66 +         */
   19.67 +        BLOCK,
   19.68  
   19.69 -    /** Do-while loops, of type DoLoop.
   19.70 -     */
   19.71 -    public static final int DOLOOP = BLOCK + 1;
   19.72 +        /** Do-while loops, of type DoLoop.
   19.73 +         */
   19.74 +        DOLOOP,
   19.75  
   19.76 -    /** While-loops, of type WhileLoop.
   19.77 -     */
   19.78 -    public static final int WHILELOOP = DOLOOP + 1;
   19.79 +        /** While-loops, of type WhileLoop.
   19.80 +         */
   19.81 +        WHILELOOP,
   19.82  
   19.83 -    /** For-loops, of type ForLoop.
   19.84 -     */
   19.85 -    public static final int FORLOOP = WHILELOOP + 1;
   19.86 +        /** For-loops, of type ForLoop.
   19.87 +         */
   19.88 +        FORLOOP,
   19.89  
   19.90 -    /** Foreach-loops, of type ForeachLoop.
   19.91 -     */
   19.92 -    public static final int FOREACHLOOP = FORLOOP + 1;
   19.93 +        /** Foreach-loops, of type ForeachLoop.
   19.94 +         */
   19.95 +        FOREACHLOOP,
   19.96  
   19.97 -    /** Labelled statements, of type Labelled.
   19.98 -     */
   19.99 -    public static final int LABELLED = FOREACHLOOP + 1;
  19.100 +        /** Labelled statements, of type Labelled.
  19.101 +         */
  19.102 +        LABELLED,
  19.103  
  19.104 -    /** Switch statements, of type Switch.
  19.105 -     */
  19.106 -    public static final int SWITCH = LABELLED + 1;
  19.107 +        /** Switch statements, of type Switch.
  19.108 +         */
  19.109 +        SWITCH,
  19.110  
  19.111 -    /** Case parts in switch statements, of type Case.
  19.112 -     */
  19.113 -    public static final int CASE = SWITCH + 1;
  19.114 +        /** Case parts in switch statements, of type Case.
  19.115 +         */
  19.116 +        CASE,
  19.117  
  19.118 -    /** Synchronized statements, of type Synchonized.
  19.119 -     */
  19.120 -    public static final int SYNCHRONIZED = CASE + 1;
  19.121 +        /** Synchronized statements, of type Synchonized.
  19.122 +         */
  19.123 +        SYNCHRONIZED,
  19.124  
  19.125 -    /** Try statements, of type Try.
  19.126 -     */
  19.127 -    public static final int TRY = SYNCHRONIZED + 1;
  19.128 +        /** Try statements, of type Try.
  19.129 +         */
  19.130 +        TRY,
  19.131  
  19.132 -    /** Catch clauses in try statements, of type Catch.
  19.133 -     */
  19.134 -    public static final int CATCH = TRY + 1;
  19.135 +        /** Catch clauses in try statements, of type Catch.
  19.136 +         */
  19.137 +        CATCH,
  19.138  
  19.139 -    /** Conditional expressions, of type Conditional.
  19.140 -     */
  19.141 -    public static final int CONDEXPR = CATCH + 1;
  19.142 +        /** Conditional expressions, of type Conditional.
  19.143 +         */
  19.144 +        CONDEXPR,
  19.145  
  19.146 -    /** Conditional statements, of type If.
  19.147 -     */
  19.148 -    public static final int IF = CONDEXPR + 1;
  19.149 +        /** Conditional statements, of type If.
  19.150 +         */
  19.151 +        IF,
  19.152  
  19.153 -    /** Expression statements, of type Exec.
  19.154 -     */
  19.155 -    public static final int EXEC = IF + 1;
  19.156 +        /** Expression statements, of type Exec.
  19.157 +         */
  19.158 +        EXEC,
  19.159  
  19.160 -    /** Break statements, of type Break.
  19.161 -     */
  19.162 -    public static final int BREAK = EXEC + 1;
  19.163 +        /** Break statements, of type Break.
  19.164 +         */
  19.165 +        BREAK,
  19.166  
  19.167 -    /** Continue statements, of type Continue.
  19.168 -     */
  19.169 -    public static final int CONTINUE = BREAK + 1;
  19.170 +        /** Continue statements, of type Continue.
  19.171 +         */
  19.172 +        CONTINUE,
  19.173  
  19.174 -    /** Return statements, of type Return.
  19.175 -     */
  19.176 -    public static final int RETURN = CONTINUE + 1;
  19.177 +        /** Return statements, of type Return.
  19.178 +         */
  19.179 +        RETURN,
  19.180  
  19.181 -    /** Throw statements, of type Throw.
  19.182 -     */
  19.183 -    public static final int THROW = RETURN + 1;
  19.184 +        /** Throw statements, of type Throw.
  19.185 +         */
  19.186 +        THROW,
  19.187  
  19.188 -    /** Assert statements, of type Assert.
  19.189 -     */
  19.190 -    public static final int ASSERT = THROW + 1;
  19.191 +        /** Assert statements, of type Assert.
  19.192 +         */
  19.193 +        ASSERT,
  19.194  
  19.195 -    /** Method invocation expressions, of type Apply.
  19.196 -     */
  19.197 -    public static final int APPLY = ASSERT + 1;
  19.198 +        /** Method invocation expressions, of type Apply.
  19.199 +         */
  19.200 +        APPLY,
  19.201  
  19.202 -    /** Class instance creation expressions, of type NewClass.
  19.203 -     */
  19.204 -    public static final int NEWCLASS = APPLY + 1;
  19.205 +        /** Class instance creation expressions, of type NewClass.
  19.206 +         */
  19.207 +        NEWCLASS,
  19.208  
  19.209 -    /** Array creation expressions, of type NewArray.
  19.210 -     */
  19.211 -    public static final int NEWARRAY = NEWCLASS + 1;
  19.212 +        /** Array creation expressions, of type NewArray.
  19.213 +         */
  19.214 +        NEWARRAY,
  19.215  
  19.216 -    /** Parenthesized subexpressions, of type Parens.
  19.217 -     */
  19.218 -    public static final int PARENS = NEWARRAY + 1;
  19.219 +        /** Parenthesized subexpressions, of type Parens.
  19.220 +         */
  19.221 +        PARENS,
  19.222  
  19.223 -    /** Assignment expressions, of type Assign.
  19.224 -     */
  19.225 -    public static final int ASSIGN = PARENS + 1;
  19.226 +        /** Assignment expressions, of type Assign.
  19.227 +         */
  19.228 +        ASSIGN,
  19.229  
  19.230 -    /** Type cast expressions, of type TypeCast.
  19.231 -     */
  19.232 -    public static final int TYPECAST = ASSIGN + 1;
  19.233 +        /** Type cast expressions, of type TypeCast.
  19.234 +         */
  19.235 +        TYPECAST,
  19.236  
  19.237 -    /** Type test expressions, of type TypeTest.
  19.238 -     */
  19.239 -    public static final int TYPETEST = TYPECAST + 1;
  19.240 +        /** Type test expressions, of type TypeTest.
  19.241 +         */
  19.242 +        TYPETEST,
  19.243  
  19.244 -    /** Indexed array expressions, of type Indexed.
  19.245 -     */
  19.246 -    public static final int INDEXED = TYPETEST + 1;
  19.247 +        /** Indexed array expressions, of type Indexed.
  19.248 +         */
  19.249 +        INDEXED,
  19.250  
  19.251 -    /** Selections, of type Select.
  19.252 -     */
  19.253 -    public static final int SELECT = INDEXED + 1;
  19.254 +        /** Selections, of type Select.
  19.255 +         */
  19.256 +        SELECT,
  19.257  
  19.258 -    /** Simple identifiers, of type Ident.
  19.259 -     */
  19.260 -    public static final int IDENT = SELECT + 1;
  19.261 +        /** Simple identifiers, of type Ident.
  19.262 +         */
  19.263 +        IDENT,
  19.264  
  19.265 -    /** Literals, of type Literal.
  19.266 -     */
  19.267 -    public static final int LITERAL = IDENT + 1;
  19.268 +        /** Literals, of type Literal.
  19.269 +         */
  19.270 +        LITERAL,
  19.271  
  19.272 -    /** Basic type identifiers, of type TypeIdent.
  19.273 -     */
  19.274 -    public static final int TYPEIDENT = LITERAL + 1;
  19.275 +        /** Basic type identifiers, of type TypeIdent.
  19.276 +         */
  19.277 +        TYPEIDENT,
  19.278  
  19.279 -    /** Array types, of type TypeArray.
  19.280 -     */
  19.281 -    public static final int TYPEARRAY = TYPEIDENT + 1;
  19.282 +        /** Array types, of type TypeArray.
  19.283 +         */
  19.284 +        TYPEARRAY,
  19.285  
  19.286 -    /** Parameterized types, of type TypeApply.
  19.287 -     */
  19.288 -    public static final int TYPEAPPLY = TYPEARRAY + 1;
  19.289 +        /** Parameterized types, of type TypeApply.
  19.290 +         */
  19.291 +        TYPEAPPLY,
  19.292  
  19.293 -    /** Union types, of type TypeUnion
  19.294 -     */
  19.295 -    public static final int TYPEUNION = TYPEAPPLY + 1;
  19.296 +        /** Union types, of type TypeUnion
  19.297 +         */
  19.298 +        TYPEUNION,
  19.299  
  19.300 -    /** Formal type parameters, of type TypeParameter.
  19.301 -     */
  19.302 -    public static final int TYPEPARAMETER = TYPEUNION + 1;
  19.303 +        /** Formal type parameters, of type TypeParameter.
  19.304 +         */
  19.305 +        TYPEPARAMETER,
  19.306  
  19.307 -    /** Type argument.
  19.308 -     */
  19.309 -    public static final int WILDCARD = TYPEPARAMETER + 1;
  19.310 +        /** Type argument.
  19.311 +         */
  19.312 +        WILDCARD,
  19.313  
  19.314 -    /** Bound kind: extends, super, exact, or unbound
  19.315 -     */
  19.316 -    public static final int TYPEBOUNDKIND = WILDCARD + 1;
  19.317 +        /** Bound kind: extends, super, exact, or unbound
  19.318 +         */
  19.319 +        TYPEBOUNDKIND,
  19.320  
  19.321 -    /** metadata: Annotation.
  19.322 -     */
  19.323 -    public static final int ANNOTATION = TYPEBOUNDKIND + 1;
  19.324 +        /** metadata: Annotation.
  19.325 +         */
  19.326 +        ANNOTATION,
  19.327  
  19.328 -    /** metadata: Modifiers
  19.329 -     */
  19.330 -    public static final int MODIFIERS = ANNOTATION + 1;
  19.331 +        /** metadata: Modifiers
  19.332 +         */
  19.333 +        MODIFIERS,
  19.334  
  19.335 -    public static final int ANNOTATED_TYPE = MODIFIERS + 1;
  19.336 +        ANNOTATED_TYPE,
  19.337  
  19.338 -    /** Error trees, of type Erroneous.
  19.339 -     */
  19.340 -    public static final int ERRONEOUS = ANNOTATED_TYPE + 1;
  19.341 +        /** Error trees, of type Erroneous.
  19.342 +         */
  19.343 +        ERRONEOUS,
  19.344  
  19.345 -    /** Unary operators, of type Unary.
  19.346 -     */
  19.347 -    public static final int POS = ERRONEOUS + 1;             // +
  19.348 -    public static final int NEG = POS + 1;                   // -
  19.349 -    public static final int NOT = NEG + 1;                   // !
  19.350 -    public static final int COMPL = NOT + 1;                 // ~
  19.351 -    public static final int PREINC = COMPL + 1;              // ++ _
  19.352 -    public static final int PREDEC = PREINC + 1;             // -- _
  19.353 -    public static final int POSTINC = PREDEC + 1;            // _ ++
  19.354 -    public static final int POSTDEC = POSTINC + 1;           // _ --
  19.355 +        /** Unary operators, of type Unary.
  19.356 +         */
  19.357 +        POS,                             // +
  19.358 +        NEG,                             // -
  19.359 +        NOT,                             // !
  19.360 +        COMPL,                           // ~
  19.361 +        PREINC,                          // ++ _
  19.362 +        PREDEC,                          // -- _
  19.363 +        POSTINC,                         // _ ++
  19.364 +        POSTDEC,                         // _ --
  19.365  
  19.366 -    /** unary operator for null reference checks, only used internally.
  19.367 -     */
  19.368 -    public static final int NULLCHK = POSTDEC + 1;
  19.369 +        /** unary operator for null reference checks, only used internally.
  19.370 +         */
  19.371 +        NULLCHK,
  19.372  
  19.373 -    /** Binary operators, of type Binary.
  19.374 -     */
  19.375 -    public static final int OR = NULLCHK + 1;                // ||
  19.376 -    public static final int AND = OR + 1;                    // &&
  19.377 -    public static final int BITOR = AND + 1;                 // |
  19.378 -    public static final int BITXOR = BITOR + 1;              // ^
  19.379 -    public static final int BITAND = BITXOR + 1;             // &
  19.380 -    public static final int EQ = BITAND + 1;                 // ==
  19.381 -    public static final int NE = EQ + 1;                     // !=
  19.382 -    public static final int LT = NE + 1;                     // <
  19.383 -    public static final int GT = LT + 1;                     // >
  19.384 -    public static final int LE = GT + 1;                     // <=
  19.385 -    public static final int GE = LE + 1;                     // >=
  19.386 -    public static final int SL = GE + 1;                     // <<
  19.387 -    public static final int SR = SL + 1;                     // >>
  19.388 -    public static final int USR = SR + 1;                    // >>>
  19.389 -    public static final int PLUS = USR + 1;                  // +
  19.390 -    public static final int MINUS = PLUS + 1;                // -
  19.391 -    public static final int MUL = MINUS + 1;                 // *
  19.392 -    public static final int DIV = MUL + 1;                   // /
  19.393 -    public static final int MOD = DIV + 1;                   // %
  19.394 +        /** Binary operators, of type Binary.
  19.395 +         */
  19.396 +        OR,                              // ||
  19.397 +        AND,                             // &&
  19.398 +        BITOR,                           // |
  19.399 +        BITXOR,                          // ^
  19.400 +        BITAND,                          // &
  19.401 +        EQ,                              // ==
  19.402 +        NE,                              // !=
  19.403 +        LT,                              // <
  19.404 +        GT,                              // >
  19.405 +        LE,                              // <=
  19.406 +        GE,                              // >=
  19.407 +        SL,                              // <<
  19.408 +        SR,                              // >>
  19.409 +        USR,                             // >>>
  19.410 +        PLUS,                            // +
  19.411 +        MINUS,                           // -
  19.412 +        MUL,                             // *
  19.413 +        DIV,                             // /
  19.414 +        MOD,                             // %
  19.415  
  19.416 -    /** Assignment operators, of type Assignop.
  19.417 -     */
  19.418 -    public static final int BITOR_ASG = MOD + 1;             // |=
  19.419 -    public static final int BITXOR_ASG = BITOR_ASG + 1;      // ^=
  19.420 -    public static final int BITAND_ASG = BITXOR_ASG + 1;     // &=
  19.421 +        /** Assignment operators, of type Assignop.
  19.422 +         */
  19.423 +        BITOR_ASG(BITOR),                // |=
  19.424 +        BITXOR_ASG(BITXOR),              // ^=
  19.425 +        BITAND_ASG(BITAND),              // &=
  19.426  
  19.427 -    public static final int SL_ASG = SL + BITOR_ASG - BITOR; // <<=
  19.428 -    public static final int SR_ASG = SL_ASG + 1;             // >>=
  19.429 -    public static final int USR_ASG = SR_ASG + 1;            // >>>=
  19.430 -    public static final int PLUS_ASG = USR_ASG + 1;          // +=
  19.431 -    public static final int MINUS_ASG = PLUS_ASG + 1;        // -=
  19.432 -    public static final int MUL_ASG = MINUS_ASG + 1;         // *=
  19.433 -    public static final int DIV_ASG = MUL_ASG + 1;           // /=
  19.434 -    public static final int MOD_ASG = DIV_ASG + 1;           // %=
  19.435 +        SL_ASG(SL),                      // <<=
  19.436 +        SR_ASG(SR),                      // >>=
  19.437 +        USR_ASG(USR),                    // >>>=
  19.438 +        PLUS_ASG(PLUS),                  // +=
  19.439 +        MINUS_ASG(MINUS),                // -=
  19.440 +        MUL_ASG(MUL),                    // *=
  19.441 +        DIV_ASG(DIV),                    // /=
  19.442 +        MOD_ASG(MOD),                    // %=
  19.443  
  19.444 -    /** A synthetic let expression, of type LetExpr.
  19.445 -     */
  19.446 -    public static final int LETEXPR = MOD_ASG + 1;           // ala scheme
  19.447 +        /** A synthetic let expression, of type LetExpr.
  19.448 +         */
  19.449 +        LETEXPR;                         // ala scheme
  19.450  
  19.451 +        private Tag noAssignTag;
  19.452  
  19.453 -    /** The offset between assignment operators and normal operators.
  19.454 -     */
  19.455 -    public static final int ASGOffset = BITOR_ASG - BITOR;
  19.456 +        private static int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1;
  19.457 +
  19.458 +        private Tag(Tag noAssignTag) {
  19.459 +            this.noAssignTag = noAssignTag;
  19.460 +        }
  19.461 +
  19.462 +        private Tag() { }
  19.463 +
  19.464 +        public static int getNumberOfOperators() {
  19.465 +            return numberOfOperators;
  19.466 +        }
  19.467 +
  19.468 +        public Tag noAssignOp() {
  19.469 +            if (noAssignTag != null)
  19.470 +                return noAssignTag;
  19.471 +            throw new AssertionError("noAssignOp() method is not available for non assignment tags");
  19.472 +        }
  19.473 +
  19.474 +        public boolean isPostUnaryOp() {
  19.475 +            return (this == POSTINC || this == POSTDEC);
  19.476 +        }
  19.477 +
  19.478 +        public boolean isIncOrDecUnaryOp() {
  19.479 +            return (this == PREINC || this == PREDEC || this == POSTINC || this == POSTDEC);
  19.480 +        }
  19.481 +
  19.482 +        public boolean isAssignop() {
  19.483 +            return noAssignTag != null;
  19.484 +        }
  19.485 +
  19.486 +        public int operatorIndex() {
  19.487 +            return (this.ordinal() - POS.ordinal());
  19.488 +        }
  19.489 +    }
  19.490  
  19.491      /* The (encoded) position in the source file. @see util.Position.
  19.492       */
  19.493 @@ -337,7 +374,13 @@
  19.494  
  19.495      /* The tag of this node -- one of the constants declared above.
  19.496       */
  19.497 -    public abstract int getTag();
  19.498 +    public abstract Tag getTag();
  19.499 +
  19.500 +    /* Returns true if the tag of this node is equals to tag.
  19.501 +     */
  19.502 +    public boolean hasTag(Tag tag) {
  19.503 +        return tag == getTag();
  19.504 +    }
  19.505  
  19.506      /** Convert a tree to a pretty-printed string. */
  19.507      @Override
  19.508 @@ -464,10 +507,9 @@
  19.509          public List<JCImport> getImports() {
  19.510              ListBuffer<JCImport> imports = new ListBuffer<JCImport>();
  19.511              for (JCTree tree : defs) {
  19.512 -                int tag = tree.getTag();
  19.513 -                if (tag == IMPORT)
  19.514 +                if (tree.hasTag(IMPORT))
  19.515                      imports.append((JCImport)tree);
  19.516 -                else if (tag != SKIP)
  19.517 +                else if (!tree.hasTag(SKIP))
  19.518                      break;
  19.519              }
  19.520              return imports.toList();
  19.521 @@ -482,7 +524,7 @@
  19.522          public List<JCTree> getTypeDecls() {
  19.523              List<JCTree> typeDefs;
  19.524              for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail)
  19.525 -                if (typeDefs.head.getTag() != IMPORT)
  19.526 +                if (!typeDefs.head.hasTag(IMPORT))
  19.527                      break;
  19.528              return typeDefs;
  19.529          }
  19.530 @@ -492,7 +534,7 @@
  19.531          }
  19.532  
  19.533          @Override
  19.534 -        public int getTag() {
  19.535 +        public Tag getTag() {
  19.536              return TOPLEVEL;
  19.537          }
  19.538      }
  19.539 @@ -521,7 +563,7 @@
  19.540          }
  19.541  
  19.542          @Override
  19.543 -        public int getTag() {
  19.544 +        public Tag getTag() {
  19.545              return IMPORT;
  19.546          }
  19.547      }
  19.548 @@ -618,7 +660,7 @@
  19.549          }
  19.550  
  19.551          @Override
  19.552 -        public int getTag() {
  19.553 +        public Tag getTag() {
  19.554              return CLASSDEF;
  19.555          }
  19.556      }
  19.557 @@ -690,7 +732,7 @@
  19.558          }
  19.559  
  19.560          @Override
  19.561 -        public int getTag() {
  19.562 +        public Tag getTag() {
  19.563              return METHODDEF;
  19.564          }
  19.565    }
  19.566 @@ -736,7 +778,7 @@
  19.567          }
  19.568  
  19.569          @Override
  19.570 -        public int getTag() {
  19.571 +        public Tag getTag() {
  19.572              return VARDEF;
  19.573          }
  19.574      }
  19.575 @@ -757,7 +799,7 @@
  19.576          }
  19.577  
  19.578          @Override
  19.579 -        public int getTag() {
  19.580 +        public Tag getTag() {
  19.581              return SKIP;
  19.582          }
  19.583      }
  19.584 @@ -790,7 +832,7 @@
  19.585          }
  19.586  
  19.587          @Override
  19.588 -        public int getTag() {
  19.589 +        public Tag getTag() {
  19.590              return BLOCK;
  19.591          }
  19.592      }
  19.593 @@ -817,7 +859,7 @@
  19.594          }
  19.595  
  19.596          @Override
  19.597 -        public int getTag() {
  19.598 +        public Tag getTag() {
  19.599              return DOLOOP;
  19.600          }
  19.601      }
  19.602 @@ -844,7 +886,7 @@
  19.603          }
  19.604  
  19.605          @Override
  19.606 -        public int getTag() {
  19.607 +        public Tag getTag() {
  19.608              return WHILELOOP;
  19.609          }
  19.610      }
  19.611 @@ -885,7 +927,7 @@
  19.612          }
  19.613  
  19.614          @Override
  19.615 -        public int getTag() {
  19.616 +        public Tag getTag() {
  19.617              return FORLOOP;
  19.618          }
  19.619      }
  19.620 @@ -914,7 +956,7 @@
  19.621              return v.visitEnhancedForLoop(this, d);
  19.622          }
  19.623          @Override
  19.624 -        public int getTag() {
  19.625 +        public Tag getTag() {
  19.626              return FOREACHLOOP;
  19.627          }
  19.628      }
  19.629 @@ -939,7 +981,7 @@
  19.630              return v.visitLabeledStatement(this, d);
  19.631          }
  19.632          @Override
  19.633 -        public int getTag() {
  19.634 +        public Tag getTag() {
  19.635              return LABELLED;
  19.636          }
  19.637      }
  19.638 @@ -965,7 +1007,7 @@
  19.639              return v.visitSwitch(this, d);
  19.640          }
  19.641          @Override
  19.642 -        public int getTag() {
  19.643 +        public Tag getTag() {
  19.644              return SWITCH;
  19.645          }
  19.646      }
  19.647 @@ -991,7 +1033,7 @@
  19.648              return v.visitCase(this, d);
  19.649          }
  19.650          @Override
  19.651 -        public int getTag() {
  19.652 +        public Tag getTag() {
  19.653              return CASE;
  19.654          }
  19.655      }
  19.656 @@ -1017,7 +1059,7 @@
  19.657              return v.visitSynchronized(this, d);
  19.658          }
  19.659          @Override
  19.660 -        public int getTag() {
  19.661 +        public Tag getTag() {
  19.662              return SYNCHRONIZED;
  19.663          }
  19.664      }
  19.665 @@ -1057,7 +1099,7 @@
  19.666              return resources;
  19.667          }
  19.668          @Override
  19.669 -        public int getTag() {
  19.670 +        public Tag getTag() {
  19.671              return TRY;
  19.672          }
  19.673      }
  19.674 @@ -1083,7 +1125,7 @@
  19.675              return v.visitCatch(this, d);
  19.676          }
  19.677          @Override
  19.678 -        public int getTag() {
  19.679 +        public Tag getTag() {
  19.680              return CATCH;
  19.681          }
  19.682      }
  19.683 @@ -1115,7 +1157,7 @@
  19.684              return v.visitConditionalExpression(this, d);
  19.685          }
  19.686          @Override
  19.687 -        public int getTag() {
  19.688 +        public Tag getTag() {
  19.689              return CONDEXPR;
  19.690          }
  19.691      }
  19.692 @@ -1147,7 +1189,7 @@
  19.693              return v.visitIf(this, d);
  19.694          }
  19.695          @Override
  19.696 -        public int getTag() {
  19.697 +        public Tag getTag() {
  19.698              return IF;
  19.699          }
  19.700      }
  19.701 @@ -1172,7 +1214,7 @@
  19.702              return v.visitExpressionStatement(this, d);
  19.703          }
  19.704          @Override
  19.705 -        public int getTag() {
  19.706 +        public Tag getTag() {
  19.707              return EXEC;
  19.708          }
  19.709  
  19.710 @@ -1212,7 +1254,7 @@
  19.711              return v.visitBreak(this, d);
  19.712          }
  19.713          @Override
  19.714 -        public int getTag() {
  19.715 +        public Tag getTag() {
  19.716              return BREAK;
  19.717          }
  19.718      }
  19.719 @@ -1237,7 +1279,7 @@
  19.720              return v.visitContinue(this, d);
  19.721          }
  19.722          @Override
  19.723 -        public int getTag() {
  19.724 +        public Tag getTag() {
  19.725              return CONTINUE;
  19.726          }
  19.727      }
  19.728 @@ -1260,7 +1302,7 @@
  19.729              return v.visitReturn(this, d);
  19.730          }
  19.731          @Override
  19.732 -        public int getTag() {
  19.733 +        public Tag getTag() {
  19.734              return RETURN;
  19.735          }
  19.736      }
  19.737 @@ -1283,7 +1325,7 @@
  19.738              return v.visitThrow(this, d);
  19.739          }
  19.740          @Override
  19.741 -        public int getTag() {
  19.742 +        public Tag getTag() {
  19.743              return THROW;
  19.744          }
  19.745      }
  19.746 @@ -1309,7 +1351,7 @@
  19.747              return v.visitAssert(this, d);
  19.748          }
  19.749          @Override
  19.750 -        public int getTag() {
  19.751 +        public Tag getTag() {
  19.752              return ASSERT;
  19.753          }
  19.754      }
  19.755 @@ -1352,7 +1394,7 @@
  19.756              return this;
  19.757          }
  19.758          @Override
  19.759 -        public int getTag() {
  19.760 +        public Tag getTag() {
  19.761              return(APPLY);
  19.762          }
  19.763      }
  19.764 @@ -1402,7 +1444,7 @@
  19.765              return v.visitNewClass(this, d);
  19.766          }
  19.767          @Override
  19.768 -        public int getTag() {
  19.769 +        public Tag getTag() {
  19.770              return NEWCLASS;
  19.771          }
  19.772      }
  19.773 @@ -1438,7 +1480,7 @@
  19.774              return v.visitNewArray(this, d);
  19.775          }
  19.776          @Override
  19.777 -        public int getTag() {
  19.778 +        public Tag getTag() {
  19.779              return NEWARRAY;
  19.780          }
  19.781      }
  19.782 @@ -1461,7 +1503,7 @@
  19.783              return v.visitParenthesized(this, d);
  19.784          }
  19.785          @Override
  19.786 -        public int getTag() {
  19.787 +        public Tag getTag() {
  19.788              return PARENS;
  19.789          }
  19.790      }
  19.791 @@ -1487,7 +1529,7 @@
  19.792              return v.visitAssignment(this, d);
  19.793          }
  19.794          @Override
  19.795 -        public int getTag() {
  19.796 +        public Tag getTag() {
  19.797              return ASSIGN;
  19.798          }
  19.799      }
  19.800 @@ -1496,11 +1538,11 @@
  19.801       * An assignment with "+=", "|=" ...
  19.802       */
  19.803      public static class JCAssignOp extends JCExpression implements CompoundAssignmentTree {
  19.804 -        private int opcode;
  19.805 +        private Tag opcode;
  19.806          public JCExpression lhs;
  19.807          public JCExpression rhs;
  19.808          public Symbol operator;
  19.809 -        protected JCAssignOp(int opcode, JCTree lhs, JCTree rhs, Symbol operator) {
  19.810 +        protected JCAssignOp(Tag opcode, JCTree lhs, JCTree rhs, Symbol operator) {
  19.811              this.opcode = opcode;
  19.812              this.lhs = (JCExpression)lhs;
  19.813              this.rhs = (JCExpression)rhs;
  19.814 @@ -1520,7 +1562,7 @@
  19.815              return v.visitCompoundAssignment(this, d);
  19.816          }
  19.817          @Override
  19.818 -        public int getTag() {
  19.819 +        public Tag getTag() {
  19.820              return opcode;
  19.821          }
  19.822      }
  19.823 @@ -1529,10 +1571,10 @@
  19.824       * A unary operation.
  19.825       */
  19.826      public static class JCUnary extends JCExpression implements UnaryTree {
  19.827 -        private int opcode;
  19.828 +        private Tag opcode;
  19.829          public JCExpression arg;
  19.830          public Symbol operator;
  19.831 -        protected JCUnary(int opcode, JCExpression arg) {
  19.832 +        protected JCUnary(Tag opcode, JCExpression arg) {
  19.833              this.opcode = opcode;
  19.834              this.arg = arg;
  19.835          }
  19.836 @@ -1549,11 +1591,11 @@
  19.837              return v.visitUnary(this, d);
  19.838          }
  19.839          @Override
  19.840 -        public int getTag() {
  19.841 +        public Tag getTag() {
  19.842              return opcode;
  19.843          }
  19.844  
  19.845 -        public void setTag(int tag) {
  19.846 +        public void setTag(Tag tag) {
  19.847              opcode = tag;
  19.848          }
  19.849      }
  19.850 @@ -1562,11 +1604,11 @@
  19.851       * A binary operation.
  19.852       */
  19.853      public static class JCBinary extends JCExpression implements BinaryTree {
  19.854 -        private int opcode;
  19.855 +        private Tag opcode;
  19.856          public JCExpression lhs;
  19.857          public JCExpression rhs;
  19.858          public Symbol operator;
  19.859 -        protected JCBinary(int opcode,
  19.860 +        protected JCBinary(Tag opcode,
  19.861                           JCExpression lhs,
  19.862                           JCExpression rhs,
  19.863                           Symbol operator) {
  19.864 @@ -1589,7 +1631,7 @@
  19.865              return v.visitBinary(this, d);
  19.866          }
  19.867          @Override
  19.868 -        public int getTag() {
  19.869 +        public Tag getTag() {
  19.870              return opcode;
  19.871          }
  19.872      }
  19.873 @@ -1615,7 +1657,7 @@
  19.874              return v.visitTypeCast(this, d);
  19.875          }
  19.876          @Override
  19.877 -        public int getTag() {
  19.878 +        public Tag getTag() {
  19.879              return TYPECAST;
  19.880          }
  19.881      }
  19.882 @@ -1641,7 +1683,7 @@
  19.883              return v.visitInstanceOf(this, d);
  19.884          }
  19.885          @Override
  19.886 -        public int getTag() {
  19.887 +        public Tag getTag() {
  19.888              return TYPETEST;
  19.889          }
  19.890      }
  19.891 @@ -1667,7 +1709,7 @@
  19.892              return v.visitArrayAccess(this, d);
  19.893          }
  19.894          @Override
  19.895 -        public int getTag() {
  19.896 +        public Tag getTag() {
  19.897              return INDEXED;
  19.898          }
  19.899      }
  19.900 @@ -1698,7 +1740,7 @@
  19.901          }
  19.902          public Name getIdentifier() { return name; }
  19.903          @Override
  19.904 -        public int getTag() {
  19.905 +        public Tag getTag() {
  19.906              return SELECT;
  19.907          }
  19.908      }
  19.909 @@ -1724,7 +1766,8 @@
  19.910          public <R,D> R accept(TreeVisitor<R,D> v, D d) {
  19.911              return v.visitIdentifier(this, d);
  19.912          }
  19.913 -        public int getTag() {
  19.914 +        @Override
  19.915 +        public Tag getTag() {
  19.916              return IDENT;
  19.917          }
  19.918      }
  19.919 @@ -1790,7 +1833,7 @@
  19.920              return this;
  19.921          }
  19.922          @Override
  19.923 -        public int getTag() {
  19.924 +        public Tag getTag() {
  19.925              return LITERAL;
  19.926          }
  19.927      }
  19.928 @@ -1838,7 +1881,7 @@
  19.929              return v.visitPrimitiveType(this, d);
  19.930          }
  19.931          @Override
  19.932 -        public int getTag() {
  19.933 +        public Tag getTag() {
  19.934              return TYPEIDENT;
  19.935          }
  19.936      }
  19.937 @@ -1861,7 +1904,7 @@
  19.938              return v.visitArrayType(this, d);
  19.939          }
  19.940          @Override
  19.941 -        public int getTag() {
  19.942 +        public Tag getTag() {
  19.943              return TYPEARRAY;
  19.944          }
  19.945      }
  19.946 @@ -1889,7 +1932,7 @@
  19.947              return v.visitParameterizedType(this, d);
  19.948          }
  19.949          @Override
  19.950 -        public int getTag() {
  19.951 +        public Tag getTag() {
  19.952              return TYPEAPPLY;
  19.953          }
  19.954      }
  19.955 @@ -1917,7 +1960,7 @@
  19.956              return v.visitUnionType(this, d);
  19.957          }
  19.958          @Override
  19.959 -        public int getTag() {
  19.960 +        public Tag getTag() {
  19.961              return TYPEUNION;
  19.962          }
  19.963      }
  19.964 @@ -1947,7 +1990,7 @@
  19.965              return v.visitTypeParameter(this, d);
  19.966          }
  19.967          @Override
  19.968 -        public int getTag() {
  19.969 +        public Tag getTag() {
  19.970              return TYPEPARAMETER;
  19.971          }
  19.972      }
  19.973 @@ -1981,7 +2024,7 @@
  19.974              return v.visitWildcard(this, d);
  19.975          }
  19.976          @Override
  19.977 -        public int getTag() {
  19.978 +        public Tag getTag() {
  19.979              return WILDCARD;
  19.980          }
  19.981      }
  19.982 @@ -2002,7 +2045,7 @@
  19.983              throw new AssertionError("TypeBoundKind is not part of a public API");
  19.984          }
  19.985          @Override
  19.986 -        public int getTag() {
  19.987 +        public Tag getTag() {
  19.988              return TYPEBOUNDKIND;
  19.989          }
  19.990      }
  19.991 @@ -2027,7 +2070,7 @@
  19.992              return v.visitAnnotation(this, d);
  19.993          }
  19.994          @Override
  19.995 -        public int getTag() {
  19.996 +        public Tag getTag() {
  19.997              return ANNOTATION;
  19.998          }
  19.999      }
 19.1000 @@ -2054,7 +2097,7 @@
 19.1001              return v.visitModifiers(this, d);
 19.1002          }
 19.1003          @Override
 19.1004 -        public int getTag() {
 19.1005 +        public Tag getTag() {
 19.1006              return MODIFIERS;
 19.1007          }
 19.1008      }
 19.1009 @@ -2079,7 +2122,7 @@
 19.1010              return v.visitErroneous(this, d);
 19.1011          }
 19.1012          @Override
 19.1013 -        public int getTag() {
 19.1014 +        public Tag getTag() {
 19.1015              return ERRONEOUS;
 19.1016          }
 19.1017      }
 19.1018 @@ -2103,7 +2146,7 @@
 19.1019              throw new AssertionError("LetExpr is not part of a public API");
 19.1020          }
 19.1021          @Override
 19.1022 -        public int getTag() {
 19.1023 +        public Tag getTag() {
 19.1024              return LETEXPR;
 19.1025          }
 19.1026      }
 19.1027 @@ -2175,9 +2218,9 @@
 19.1028                            List<JCExpression> elems);
 19.1029          JCParens Parens(JCExpression expr);
 19.1030          JCAssign Assign(JCExpression lhs, JCExpression rhs);
 19.1031 -        JCAssignOp Assignop(int opcode, JCTree lhs, JCTree rhs);
 19.1032 -        JCUnary Unary(int opcode, JCExpression arg);
 19.1033 -        JCBinary Binary(int opcode, JCExpression lhs, JCExpression rhs);
 19.1034 +        JCAssignOp Assignop(Tag opcode, JCTree lhs, JCTree rhs);
 19.1035 +        JCUnary Unary(Tag opcode, JCExpression arg);
 19.1036 +        JCBinary Binary(Tag opcode, JCExpression lhs, JCExpression rhs);
 19.1037          JCTypeCast TypeCast(JCTree expr, JCExpression type);
 19.1038          JCInstanceOf TypeTest(JCExpression expr, JCTree clazz);
 19.1039          JCArrayAccess Indexed(JCExpression indexed, JCExpression index);

    20.1 --- a/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Sat Nov 05 00:02:33 2011 -0700
    20.2 +++ b/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Tue Nov 08 11:51:05 2011 -0800
    20.3 @@ -36,6 +36,8 @@
    20.4  import com.sun.tools.javac.tree.JCTree.*;
    20.5  
    20.6  import static com.sun.tools.javac.code.Flags.*;
    20.7 +import static com.sun.tools.javac.code.Flags.ANNOTATION;
    20.8 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    20.9  
   20.10  /** Prints out a tree as an indented Java source program.
   20.11   *
   20.12 @@ -310,7 +312,7 @@
   20.13  
   20.14      /** Is the given tree an enumerator definition? */
   20.15      boolean isEnumerator(JCTree t) {
   20.16 -        return t.getTag() == JCTree.VARDEF && (((JCVariableDecl) t).mods.flags & ENUM) != 0;
   20.17 +        return t.hasTag(VARDEF) && (((JCVariableDecl) t).mods.flags & ENUM) != 0;
   20.18      }
   20.19  
   20.20      /** Print unit consisting of package clause and import statements in toplevel,
   20.21 @@ -331,9 +333,9 @@
   20.22          }
   20.23          boolean firstImport = true;
   20.24          for (List<JCTree> l = tree.defs;
   20.25 -        l.nonEmpty() && (cdef == null || l.head.getTag() == JCTree.IMPORT);
   20.26 +        l.nonEmpty() && (cdef == null || l.head.hasTag(IMPORT));
   20.27          l = l.tail) {
   20.28 -            if (l.head.getTag() == JCTree.IMPORT) {
   20.29 +            if (l.head.hasTag(IMPORT)) {
   20.30                  JCImport imp = (JCImport)l.head;
   20.31                  Name name = TreeInfo.name(imp.qualid);
   20.32                  if (name == name.table.names.asterisk ||
   20.33 @@ -484,7 +486,7 @@
   20.34                  print("/*public static final*/ ");
   20.35                  print(tree.name);
   20.36                  if (tree.init != null) {
   20.37 -                    if (sourceOutput && tree.init.getTag() == JCTree.NEWCLASS) {
   20.38 +                    if (sourceOutput && tree.init.hasTag(NEWCLASS)) {
   20.39                          print(" /*enum*/ ");
   20.40                          JCNewClass init = (JCNewClass) tree.init;
   20.41                          if (init.args != null && init.args.nonEmpty()) {
   20.42 @@ -545,7 +547,7 @@
   20.43              printStat(tree.body);
   20.44              align();
   20.45              print(" while ");
   20.46 -            if (tree.cond.getTag() == JCTree.PARENS) {
   20.47 +            if (tree.cond.hasTag(PARENS)) {
   20.48                  printExpr(tree.cond);
   20.49              } else {
   20.50                  print("(");
   20.51 @@ -561,7 +563,7 @@
   20.52      public void visitWhileLoop(JCWhileLoop tree) {
   20.53          try {
   20.54              print("while ");
   20.55 -            if (tree.cond.getTag() == JCTree.PARENS) {
   20.56 +            if (tree.cond.hasTag(PARENS)) {
   20.57                  printExpr(tree.cond);
   20.58              } else {
   20.59                  print("(");
   20.60 @@ -579,7 +581,7 @@
   20.61          try {
   20.62              print("for (");
   20.63              if (tree.init.nonEmpty()) {
   20.64 -                if (tree.init.head.getTag() == JCTree.VARDEF) {
   20.65 +                if (tree.init.head.hasTag(VARDEF)) {
   20.66                      printExpr(tree.init.head);
   20.67                      for (List<JCStatement> l = tree.init.tail; l.nonEmpty(); l = l.tail) {
   20.68                          JCVariableDecl vdef = (JCVariableDecl)l.head;
   20.69 @@ -626,7 +628,7 @@
   20.70      public void visitSwitch(JCSwitch tree) {
   20.71          try {
   20.72              print("switch ");
   20.73 -            if (tree.selector.getTag() == JCTree.PARENS) {
   20.74 +            if (tree.selector.hasTag(PARENS)) {
   20.75                  printExpr(tree.selector);
   20.76              } else {
   20.77                  print("(");
   20.78 @@ -665,7 +667,7 @@
   20.79      public void visitSynchronized(JCSynchronized tree) {
   20.80          try {
   20.81              print("synchronized ");
   20.82 -            if (tree.lock.getTag() == JCTree.PARENS) {
   20.83 +            if (tree.lock.hasTag(PARENS)) {
   20.84                  printExpr(tree.lock);
   20.85              } else {
   20.86                  print("(");
   20.87 @@ -736,7 +738,7 @@
   20.88      public void visitIf(JCIf tree) {
   20.89          try {
   20.90              print("if ");
   20.91 -            if (tree.cond.getTag() == JCTree.PARENS) {
   20.92 +            if (tree.cond.hasTag(PARENS)) {
   20.93                  printExpr(tree.cond);
   20.94              } else {
   20.95                  print("(");
   20.96 @@ -823,7 +825,7 @@
   20.97      public void visitApply(JCMethodInvocation tree) {
   20.98          try {
   20.99              if (!tree.typeargs.isEmpty()) {
  20.100 -                if (tree.meth.getTag() == JCTree.SELECT) {
  20.101 +                if (tree.meth.hasTag(SELECT)) {
  20.102                      JCFieldAccess left = (JCFieldAccess)tree.meth;
  20.103                      printExpr(left.selected);
  20.104                      print(".<");
  20.105 @@ -882,7 +884,7 @@
  20.106              if (tree.elemtype != null) {
  20.107                  print("new ");
  20.108                  JCTree elem = tree.elemtype;
  20.109 -                if (elem.getTag() == JCTree.TYPEARRAY)
  20.110 +                if (elem.hasTag(TYPEARRAY))
  20.111                      printBaseElementType((JCArrayTypeTree) elem);
  20.112                  else
  20.113                      printExpr(elem);
  20.114 @@ -927,36 +929,36 @@
  20.115          }
  20.116      }
  20.117  
  20.118 -    public String operatorName(int tag) {
  20.119 +    public String operatorName(JCTree.Tag tag) {
  20.120          switch(tag) {
  20.121 -            case JCTree.POS:     return "+";
  20.122 -            case JCTree.NEG:     return "-";
  20.123 -            case JCTree.NOT:     return "!";
  20.124 -            case JCTree.COMPL:   return "~";
  20.125 -            case JCTree.PREINC:  return "++";
  20.126 -            case JCTree.PREDEC:  return "--";
  20.127 -            case JCTree.POSTINC: return "++";
  20.128 -            case JCTree.POSTDEC: return "--";
  20.129 -            case JCTree.NULLCHK: return "<*nullchk*>";
  20.130 -            case JCTree.OR:      return "||";
  20.131 -            case JCTree.AND:     return "&&";
  20.132 -            case JCTree.EQ:      return "==";
  20.133 -            case JCTree.NE:      return "!=";
  20.134 -            case JCTree.LT:      return "<";
  20.135 -            case JCTree.GT:      return ">";
  20.136 -            case JCTree.LE:      return "<=";
  20.137 -            case JCTree.GE:      return ">=";
  20.138 -            case JCTree.BITOR:   return "|";
  20.139 -            case JCTree.BITXOR:  return "^";
  20.140 -            case JCTree.BITAND:  return "&";
  20.141 -            case JCTree.SL:      return "<<";
  20.142 -            case JCTree.SR:      return ">>";
  20.143 -            case JCTree.USR:     return ">>>";
  20.144 -            case JCTree.PLUS:    return "+";
  20.145 -            case JCTree.MINUS:   return "-";
  20.146 -            case JCTree.MUL:     return "*";
  20.147 -            case JCTree.DIV:     return "/";
  20.148 -            case JCTree.MOD:     return "%";
  20.149 +            case POS:     return "+";
  20.150 +            case NEG:     return "-";
  20.151 +            case NOT:     return "!";
  20.152 +            case COMPL:   return "~";
  20.153 +            case PREINC:  return "++";
  20.154 +            case PREDEC:  return "--";
  20.155 +            case POSTINC: return "++";
  20.156 +            case POSTDEC: return "--";
  20.157 +            case NULLCHK: return "<*nullchk*>";
  20.158 +            case OR:      return "||";
  20.159 +            case AND:     return "&&";
  20.160 +            case EQ:      return "==";
  20.161 +            case NE:      return "!=";
  20.162 +            case LT:      return "<";
  20.163 +            case GT:      return ">";
  20.164 +            case LE:      return "<=";
  20.165 +            case GE:      return ">=";
  20.166 +            case BITOR:   return "|";
  20.167 +            case BITXOR:  return "^";
  20.168 +            case BITAND:  return "&";
  20.169 +            case SL:      return "<<";
  20.170 +            case SR:      return ">>";
  20.171 +            case USR:     return ">>>";
  20.172 +            case PLUS:    return "+";
  20.173 +            case MINUS:   return "-";
  20.174 +            case MUL:     return "*";
  20.175 +            case DIV:     return "/";
  20.176 +            case MOD:     return "%";
  20.177              default: throw new Error();
  20.178          }
  20.179      }
  20.180 @@ -965,7 +967,7 @@
  20.181          try {
  20.182              open(prec, TreeInfo.assignopPrec);
  20.183              printExpr(tree.lhs, TreeInfo.assignopPrec + 1);
  20.184 -            print(" " + operatorName(tree.getTag() - JCTree.ASGOffset) + "= ");
  20.185 +            print(" " + operatorName(tree.getTag().noAssignOp()) + "= ");
  20.186              printExpr(tree.rhs, TreeInfo.assignopPrec);
  20.187              close(prec, TreeInfo.assignopPrec);
  20.188          } catch (IOException e) {
  20.189 @@ -978,7 +980,7 @@
  20.190              int ownprec = TreeInfo.opPrec(tree.getTag());
  20.191              String opname = operatorName(tree.getTag());
  20.192              open(prec, ownprec);
  20.193 -            if (tree.getTag() <= JCTree.PREDEC) {
  20.194 +            if (!tree.getTag().isPostUnaryOp()) {
  20.195                  print(opname);
  20.196                  printExpr(tree.arg, ownprec);
  20.197              } else {
  20.198 @@ -1153,7 +1155,7 @@
  20.199          while (true) {
  20.200              elem = tree.elemtype;
  20.201              print("[]");
  20.202 -            if (elem.getTag() != JCTree.TYPEARRAY) break;
  20.203 +            if (!elem.hasTag(TYPEARRAY)) break;
  20.204              tree = (JCArrayTypeTree) elem;
  20.205          }
  20.206      }

    21.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java	Sat Nov 05 00:02:33 2011 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java	Tue Nov 08 11:51:05 2011 -0800
    21.3 @@ -406,7 +406,7 @@
    21.4      public JCTree visitOther(Tree node, P p) {
    21.5          JCTree tree = (JCTree) node;
    21.6          switch (tree.getTag()) {
    21.7 -            case JCTree.LETEXPR: {
    21.8 +            case LETEXPR: {
    21.9                  LetExpr t = (LetExpr) node;
   21.10                  List<JCVariableDecl> defs = copy(t.defs, p);
   21.11                  JCTree expr = copy(t.expr, p);

    22.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Sat Nov 05 00:02:33 2011 -0700
    22.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java	Tue Nov 08 11:51:05 2011 -0800
    22.3 @@ -35,6 +35,9 @@
    22.4  import com.sun.tools.javac.tree.JCTree.*;
    22.5  
    22.6  import static com.sun.tools.javac.code.Flags.*;
    22.7 +import static com.sun.tools.javac.tree.JCTree.Tag.*;
    22.8 +import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
    22.9 +import static com.sun.tools.javac.tree.JCTree.Tag.SYNCHRONIZED;
   22.10  
   22.11  /** Utility class containing inspector methods for trees.
   22.12   *
   22.13 @@ -56,53 +59,60 @@
   22.14  
   22.15      /** The names of all operators.
   22.16       */
   22.17 -    private Name[] opname = new Name[JCTree.MOD - JCTree.POS + 1];
   22.18 +    private Name[] opname = new Name[Tag.getNumberOfOperators()];
   22.19 +
   22.20 +    private void setOpname(Tag tag, String name, Names names) {
   22.21 +         setOpname(tag, names.fromString(name));
   22.22 +     }
   22.23 +     private void setOpname(Tag tag, Name name) {
   22.24 +         opname[tag.operatorIndex()] = name;
   22.25 +     }
   22.26  
   22.27      private TreeInfo(Context context) {
   22.28          context.put(treeInfoKey, this);
   22.29  
   22.30          Names names = Names.instance(context);
   22.31 -        opname[JCTree.POS     - JCTree.POS] = names.fromString("+");
   22.32 -        opname[JCTree.NEG     - JCTree.POS] = names.hyphen;
   22.33 -        opname[JCTree.NOT     - JCTree.POS] = names.fromString("!");
   22.34 -        opname[JCTree.COMPL   - JCTree.POS] = names.fromString("~");
   22.35 -        opname[JCTree.PREINC  - JCTree.POS] = names.fromString("++");
   22.36 -        opname[JCTree.PREDEC  - JCTree.POS] = names.fromString("--");
   22.37 -        opname[JCTree.POSTINC - JCTree.POS] = names.fromString("++");
   22.38 -        opname[JCTree.POSTDEC - JCTree.POS] = names.fromString("--");
   22.39 -        opname[JCTree.NULLCHK - JCTree.POS] = names.fromString("<*nullchk*>");
   22.40 -        opname[JCTree.OR      - JCTree.POS] = names.fromString("||");
   22.41 -        opname[JCTree.AND     - JCTree.POS] = names.fromString("&&");
   22.42 -        opname[JCTree.EQ      - JCTree.POS] = names.fromString("==");
   22.43 -        opname[JCTree.NE      - JCTree.POS] = names.fromString("!=");
   22.44 -        opname[JCTree.LT      - JCTree.POS] = names.fromString("<");
   22.45 -        opname[JCTree.GT      - JCTree.POS] = names.fromString(">");
   22.46 -        opname[JCTree.LE      - JCTree.POS] = names.fromString("<=");
   22.47 -        opname[JCTree.GE      - JCTree.POS] = names.fromString(">=");
   22.48 -        opname[JCTree.BITOR   - JCTree.POS] = names.fromString("|");
   22.49 -        opname[JCTree.BITXOR  - JCTree.POS] = names.fromString("^");
   22.50 -        opname[JCTree.BITAND  - JCTree.POS] = names.fromString("&");
   22.51 -        opname[JCTree.SL      - JCTree.POS] = names.fromString("<<");
   22.52 -        opname[JCTree.SR      - JCTree.POS] = names.fromString(">>");
   22.53 -        opname[JCTree.USR     - JCTree.POS] = names.fromString(">>>");
   22.54 -        opname[JCTree.PLUS    - JCTree.POS] = names.fromString("+");
   22.55 -        opname[JCTree.MINUS   - JCTree.POS] = names.hyphen;
   22.56 -        opname[JCTree.MUL     - JCTree.POS] = names.asterisk;
   22.57 -        opname[JCTree.DIV     - JCTree.POS] = names.slash;
   22.58 -        opname[JCTree.MOD     - JCTree.POS] = names.fromString("%");
   22.59 +        setOpname(POS, "+", names);
   22.60 +        setOpname(NEG, names.hyphen);
   22.61 +        setOpname(NOT, "!", names);
   22.62 +        setOpname(COMPL, "~", names);
   22.63 +        setOpname(PREINC, "++", names);
   22.64 +        setOpname(PREDEC, "--", names);
   22.65 +        setOpname(POSTINC, "++", names);
   22.66 +        setOpname(POSTDEC, "--", names);
   22.67 +        setOpname(NULLCHK, "<*nullchk*>", names);
   22.68 +        setOpname(OR, "||", names);
   22.69 +        setOpname(AND, "&&", names);
   22.70 +        setOpname(EQ, "==", names);
   22.71 +        setOpname(NE, "!=", names);
   22.72 +        setOpname(LT, "<", names);
   22.73 +        setOpname(GT, ">", names);
   22.74 +        setOpname(LE, "<=", names);
   22.75 +        setOpname(GE, ">=", names);
   22.76 +        setOpname(BITOR, "|", names);
   22.77 +        setOpname(BITXOR, "^", names);
   22.78 +        setOpname(BITAND, "&", names);
   22.79 +        setOpname(SL, "<<", names);
   22.80 +        setOpname(SR, ">>", names);
   22.81 +        setOpname(USR, ">>>", names);
   22.82 +        setOpname(PLUS, "+", names);
   22.83 +        setOpname(MINUS, names.hyphen);
   22.84 +        setOpname(MUL, names.asterisk);
   22.85 +        setOpname(DIV, names.slash);
   22.86 +        setOpname(MOD, "%", names);
   22.87      }
   22.88  
   22.89  
   22.90      /** Return name of operator with given tree tag.
   22.91       */
   22.92 -    public Name operatorName(int tag) {
   22.93 -        return opname[tag - JCTree.POS];
   22.94 +    public Name operatorName(JCTree.Tag tag) {
   22.95 +        return opname[tag.operatorIndex()];
   22.96      }
   22.97  
   22.98      /** Is tree a constructor declaration?
   22.99       */
  22.100      public static boolean isConstructor(JCTree tree) {
  22.101 -        if (tree.getTag() == JCTree.METHODDEF) {
  22.102 +        if (tree.hasTag(METHODDEF)) {
  22.103              Name name = ((JCMethodDecl) tree).name;
  22.104              return name == name.table.names.init;
  22.105          } else {
  22.106 @@ -119,17 +129,17 @@
  22.107      }
  22.108  
  22.109      public static boolean isMultiCatch(JCCatch catchClause) {
  22.110 -        return catchClause.param.vartype.getTag() == JCTree.TYPEUNION;
  22.111 +        return catchClause.param.vartype.hasTag(TYPEUNION);
  22.112      }
  22.113  
  22.114      /** Is statement an initializer for a synthetic field?
  22.115       */
  22.116      public static boolean isSyntheticInit(JCTree stat) {
  22.117 -        if (stat.getTag() == JCTree.EXEC) {
  22.118 +        if (stat.hasTag(EXEC)) {
  22.119              JCExpressionStatement exec = (JCExpressionStatement)stat;
  22.120 -            if (exec.expr.getTag() == JCTree.ASSIGN) {
  22.121 +            if (exec.expr.hasTag(ASSIGN)) {
  22.122                  JCAssign assign = (JCAssign)exec.expr;
  22.123 -                if (assign.lhs.getTag() == JCTree.SELECT) {
  22.124 +                if (assign.lhs.hasTag(SELECT)) {
  22.125                      JCFieldAccess select = (JCFieldAccess)assign.lhs;
  22.126                      if (select.sym != null &&
  22.127                          (select.sym.flags() & SYNTHETIC) != 0) {
  22.128 @@ -146,9 +156,9 @@
  22.129      /** If the expression is a method call, return the method name, null
  22.130       *  otherwise. */
  22.131      public static Name calledMethodName(JCTree tree) {
  22.132 -        if (tree.getTag() == JCTree.EXEC) {
  22.133 +        if (tree.hasTag(EXEC)) {
  22.134              JCExpressionStatement exec = (JCExpressionStatement)tree;
  22.135 -            if (exec.expr.getTag() == JCTree.APPLY) {
  22.136 +            if (exec.expr.hasTag(APPLY)) {
  22.137                  Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
  22.138                  return mname;
  22.139              }
  22.140 @@ -192,7 +202,7 @@
  22.141  
  22.142      /** Return the first call in a constructor definition. */
  22.143      public static JCMethodInvocation firstConstructorCall(JCTree tree) {
  22.144 -        if (tree.getTag() != JCTree.METHODDEF) return null;
  22.145 +        if (!tree.hasTag(METHODDEF)) return null;
  22.146          JCMethodDecl md = (JCMethodDecl) tree;
  22.147          Names names = md.name.table.names;
  22.148          if (md.name != names.init) return null;
  22.149 @@ -202,24 +212,24 @@
  22.150          while (stats.nonEmpty() && isSyntheticInit(stats.head))
  22.151              stats = stats.tail;
  22.152          if (stats.isEmpty()) return null;
  22.153 -        if (stats.head.getTag() != JCTree.EXEC) return null;
  22.154 +        if (!stats.head.hasTag(EXEC)) return null;
  22.155          JCExpressionStatement exec = (JCExpressionStatement) stats.head;
  22.156 -        if (exec.expr.getTag() != JCTree.APPLY) return null;
  22.157 +        if (!exec.expr.hasTag(APPLY)) return null;
  22.158          return (JCMethodInvocation)exec.expr;
  22.159      }
  22.160  
  22.161      /** Return true if a tree represents a diamond new expr. */
  22.162      public static boolean isDiamond(JCTree tree) {
  22.163          switch(tree.getTag()) {
  22.164 -            case JCTree.TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
  22.165 -            case JCTree.NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
  22.166 +            case TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
  22.167 +            case NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
  22.168              default: return false;
  22.169          }
  22.170      }
  22.171  
  22.172      /** Return true if a tree represents the null literal. */
  22.173      public static boolean isNull(JCTree tree) {
  22.174 -        if (tree.getTag() != JCTree.LITERAL)
  22.175 +        if (!tree.hasTag(LITERAL))
  22.176              return false;
  22.177          JCLiteral lit = (JCLiteral) tree;
  22.178          return (lit.typetag == TypeTags.BOT);
  22.179 @@ -229,7 +239,7 @@
  22.180       *  the block itself if it is empty.
  22.181       */
  22.182      public static int firstStatPos(JCTree tree) {
  22.183 -        if (tree.getTag() == JCTree.BLOCK && ((JCBlock) tree).stats.nonEmpty())
  22.184 +        if (tree.hasTag(BLOCK) && ((JCBlock) tree).stats.nonEmpty())
  22.185              return ((JCBlock) tree).stats.head.pos;
  22.186          else
  22.187              return tree.pos;
  22.188 @@ -239,11 +249,11 @@
  22.189       *  defined endpos.
  22.190       */
  22.191      public static int endPos(JCTree tree) {
  22.192 -        if (tree.getTag() == JCTree.BLOCK && ((JCBlock) tree).endpos != Position.NOPOS)
  22.193 +        if (tree.hasTag(BLOCK) && ((JCBlock) tree).endpos != Position.NOPOS)
  22.194              return ((JCBlock) tree).endpos;
  22.195 -        else if (tree.getTag() == JCTree.SYNCHRONIZED)
  22.196 +        else if (tree.hasTag(SYNCHRONIZED))
  22.197              return endPos(((JCSynchronized) tree).body);
  22.198 -        else if (tree.getTag() == JCTree.TRY) {
  22.199 +        else if (tree.hasTag(TRY)) {
  22.200              JCTry t = (JCTry) tree;
  22.201              return endPos((t.finalizer != null)
  22.202                            ? t.finalizer
  22.203 @@ -263,73 +273,73 @@
  22.204              return Position.NOPOS;
  22.205  
  22.206          switch(tree.getTag()) {
  22.207 -        case(JCTree.APPLY):
  22.208 -            return getStartPos(((JCMethodInvocation) tree).meth);
  22.209 -        case(JCTree.ASSIGN):
  22.210 -            return getStartPos(((JCAssign) tree).lhs);
  22.211 -        case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG):
  22.212 -        case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG):
  22.213 -        case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG):
  22.214 -        case(JCTree.DIV_ASG): case(JCTree.MOD_ASG):
  22.215 -            return getStartPos(((JCAssignOp) tree).lhs);
  22.216 -        case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR):
  22.217 -        case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ):
  22.218 -        case(JCTree.NE): case(JCTree.LT): case(JCTree.GT):
  22.219 -        case(JCTree.LE): case(JCTree.GE): case(JCTree.SL):
  22.220 -        case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS):
  22.221 -        case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV):
  22.222 -        case(JCTree.MOD):
  22.223 -            return getStartPos(((JCBinary) tree).lhs);
  22.224 -        case(JCTree.CLASSDEF): {
  22.225 -            JCClassDecl node = (JCClassDecl)tree;
  22.226 -            if (node.mods.pos != Position.NOPOS)
  22.227 -                return node.mods.pos;
  22.228 -            break;
  22.229 -        }
  22.230 -        case(JCTree.CONDEXPR):
  22.231 -            return getStartPos(((JCConditional) tree).cond);
  22.232 -        case(JCTree.EXEC):
  22.233 -            return getStartPos(((JCExpressionStatement) tree).expr);
  22.234 -        case(JCTree.INDEXED):
  22.235 -            return getStartPos(((JCArrayAccess) tree).indexed);
  22.236 -        case(JCTree.METHODDEF): {
  22.237 -            JCMethodDecl node = (JCMethodDecl)tree;
  22.238 -            if (node.mods.pos != Position.NOPOS)
  22.239 -                return node.mods.pos;
  22.240 -            if (node.typarams.nonEmpty()) // List.nil() used for no typarams
  22.241 -                return getStartPos(node.typarams.head);
  22.242 -            return node.restype == null ? node.pos : getStartPos(node.restype);
  22.243 -        }
  22.244 -        case(JCTree.SELECT):
  22.245 -            return getStartPos(((JCFieldAccess) tree).selected);
  22.246 -        case(JCTree.TYPEAPPLY):
  22.247 -            return getStartPos(((JCTypeApply) tree).clazz);
  22.248 -        case(JCTree.TYPEARRAY):
  22.249 -            return getStartPos(((JCArrayTypeTree) tree).elemtype);
  22.250 -        case(JCTree.TYPETEST):
  22.251 -            return getStartPos(((JCInstanceOf) tree).expr);
  22.252 -        case(JCTree.POSTINC):
  22.253 -        case(JCTree.POSTDEC):
  22.254 -            return getStartPos(((JCUnary) tree).arg);
  22.255 -        case(JCTree.NEWCLASS): {
  22.256 -            JCNewClass node = (JCNewClass)tree;
  22.257 -            if (node.encl != null)
  22.258 -                return getStartPos(node.encl);
  22.259 -            break;
  22.260 -        }
  22.261 -        case(JCTree.VARDEF): {
  22.262 -            JCVariableDecl node = (JCVariableDecl)tree;
  22.263 -            if (node.mods.pos != Position.NOPOS) {
  22.264 -                return node.mods.pos;
  22.265 -            } else {
  22.266 -                return getStartPos(node.vartype);
  22.267 +            case APPLY:
  22.268 +                return getStartPos(((JCMethodInvocation) tree).meth);
  22.269 +            case ASSIGN:
  22.270 +                return getStartPos(((JCAssign) tree).lhs);
  22.271 +            case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
  22.272 +            case SL_ASG: case SR_ASG: case USR_ASG:
  22.273 +            case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
  22.274 +            case DIV_ASG: case MOD_ASG:
  22.275 +                return getStartPos(((JCAssignOp) tree).lhs);
  22.276 +            case OR: case AND: case BITOR:
  22.277 +            case BITXOR: case BITAND: case EQ:
  22.278 +            case NE: case LT: case GT:
  22.279 +            case LE: case GE: case SL:
  22.280 +            case SR: case USR: case PLUS:
  22.281 +            case MINUS: case MUL: case DIV:
  22.282 +            case MOD:
  22.283 +                return getStartPos(((JCBinary) tree).lhs);
  22.284 +            case CLASSDEF: {
  22.285 +                JCClassDecl node = (JCClassDecl)tree;
  22.286 +                if (node.mods.pos != Position.NOPOS)
  22.287 +                    return node.mods.pos;
  22.288 +                break;
  22.289              }
  22.290 -        }
  22.291 -        case(JCTree.ERRONEOUS): {
  22.292 -            JCErroneous node = (JCErroneous)tree;
  22.293 -            if (node.errs != null && node.errs.nonEmpty())
  22.294 -                return getStartPos(node.errs.head);
  22.295 -        }
  22.296 +            case CONDEXPR:
  22.297 +                return getStartPos(((JCConditional) tree).cond);
  22.298 +            case EXEC:
  22.299 +                return getStartPos(((JCExpressionStatement) tree).expr);
  22.300 +            case INDEXED:
  22.301 +                return getStartPos(((JCArrayAccess) tree).indexed);
  22.302 +            case METHODDEF: {
  22.303 +                JCMethodDecl node = (JCMethodDecl)tree;
  22.304 +                if (node.mods.pos != Position.NOPOS)
  22.305 +                    return node.mods.pos;
  22.306 +                if (node.typarams.nonEmpty()) // List.nil() used for no typarams
  22.307 +                    return getStartPos(node.typarams.head);
  22.308 +                return node.restype == null ? node.pos : getStartPos(node.restype);
  22.309 +            }
  22.310 +            case SELECT:
  22.311 +                return getStartPos(((JCFieldAccess) tree).selected);
  22.312 +            case TYPEAPPLY:
  22.313 +                return getStartPos(((JCTypeApply) tree).clazz);
  22.314 +            case TYPEARRAY:
  22.315 +                return getStartPos(((JCArrayTypeTree) tree).elemtype);
  22.316 +            case TYPETEST:
  22.317 +                return getStartPos(((JCInstanceOf) tree).expr);
  22.318 +            case POSTINC:
  22.319 +            case POSTDEC:
  22.320 +                return getStartPos(((JCUnary) tree).arg);
  22.321 +            case NEWCLASS: {
  22.322 +                JCNewClass node = (JCNewClass)tree;
  22.323 +                if (node.encl != null)
  22.324 +                    return getStartPos(node.encl);
  22.325 +                break;
  22.326 +            }
  22.327 +            case VARDEF: {
  22.328 +                JCVariableDecl node = (JCVariableDecl)tree;
  22.329 +                if (node.mods.pos != Position.NOPOS) {
  22.330 +                    return node.mods.pos;
  22.331 +                } else {
  22.332 +                    return getStartPos(node.vartype);
  22.333 +                }
  22.334 +            }
  22.335 +            case ERRONEOUS: {
  22.336 +                JCErroneous node = (JCErroneous)tree;
  22.337 +                if (node.errs != null && node.errs.nonEmpty())
  22.338 +                    return getStartPos(node.errs.head);
  22.339 +            }
  22.340          }
  22.341          return tree.pos;
  22.342      }
  22.343 @@ -350,75 +360,75 @@
  22.344              return mapPos;
  22.345  
  22.346          switch(tree.getTag()) {
  22.347 -        case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG):
  22.348 -        case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG):
  22.349 -        case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG):
  22.350 -        case(JCTree.DIV_ASG): case(JCTree.MOD_ASG):
  22.351 -            return getEndPos(((JCAssignOp) tree).rhs, endPositions);
  22.352 -        case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR):
  22.353 -        case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ):
  22.354 -        case(JCTree.NE): case(JCTree.LT): case(JCTree.GT):
  22.355 -        case(JCTree.LE): case(JCTree.GE): case(JCTree.SL):
  22.356 -        case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS):
  22.357 -        case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV):
  22.358 -        case(JCTree.MOD):
  22.359 -            return getEndPos(((JCBinary) tree).rhs, endPositions);
  22.360 -        case(JCTree.CASE):
  22.361 -            return getEndPos(((JCCase) tree).stats.last(), endPositions);
  22.362 -        case(JCTree.CATCH):
  22.363 -            return getEndPos(((JCCatch) tree).body, endPositions);
  22.364 -        case(JCTree.CONDEXPR):
  22.365 -            return getEndPos(((JCConditional) tree).falsepart, endPositions);
  22.366 -        case(JCTree.FORLOOP):
  22.367 -            return getEndPos(((JCForLoop) tree).body, endPositions);
  22.368 -        case(JCTree.FOREACHLOOP):
  22.369 -            return getEndPos(((JCEnhancedForLoop) tree).body, endPositions);
  22.370 -        case(JCTree.IF): {
  22.371 -            JCIf node = (JCIf)tree;
  22.372 -            if (node.elsepart == null) {
  22.373 -                return getEndPos(node.thenpart, endPositions);
  22.374 -            } else {
  22.375 -                return getEndPos(node.elsepart, endPositions);
  22.376 +            case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
  22.377 +            case SL_ASG: case SR_ASG: case USR_ASG:
  22.378 +            case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
  22.379 +            case DIV_ASG: case MOD_ASG:
  22.380 +                return getEndPos(((JCAssignOp) tree).rhs, endPositions);
  22.381 +            case OR: case AND: case BITOR:
  22.382 +            case BITXOR: case BITAND: case EQ:
  22.383 +            case NE: case LT: case GT:
  22.384 +            case LE: case GE: case SL:
  22.385 +            case SR: case USR: case PLUS:
  22.386 +            case MINUS: case MUL: case DIV:
  22.387 +            case MOD:
  22.388 +                return getEndPos(((JCBinary) tree).rhs, endPositions);
  22.389 +            case CASE:
  22.390 +                return getEndPos(((JCCase) tree).stats.last(), endPositions);
  22.391 +            case CATCH:
  22.392 +                return getEndPos(((JCCatch) tree).body, endPositions);
  22.393 +            case CONDEXPR:
  22.394 +                return getEndPos(((JCConditional) tree).falsepart, endPositions);
  22.395 +            case FORLOOP:
  22.396 +                return getEndPos(((JCForLoop) tree).body, endPositions);
  22.397 +            case FOREACHLOOP:
  22.398 +                return getEndPos(((JCEnhancedForLoop) tree).body, endPositions);
  22.399 +            case IF: {
  22.400 +                JCIf node = (JCIf)tree;
  22.401 +                if (node.elsepart == null) {
  22.402 +                    return getEndPos(node.thenpart, endPositions);
  22.403 +                } else {
  22.404 +                    return getEndPos(node.elsepart, endPositions);
  22.405 +                }
  22.406              }
  22.407 -        }
  22.408 -        case(JCTree.LABELLED):
  22.409 -            return getEndPos(((JCLabeledStatement) tree).body, endPositions);
  22.410 -        case(JCTree.MODIFIERS):
  22.411 -            return getEndPos(((JCModifiers) tree).annotations.last(), endPositions);
  22.412 -        case(JCTree.SYNCHRONIZED):
  22.413 -            return getEndPos(((JCSynchronized) tree).body, endPositions);
  22.414 -        case(JCTree.TOPLEVEL):
  22.415 -            return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions);
  22.416 -        case(JCTree.TRY): {
  22.417 -            JCTry node = (JCTry)tree;
  22.418 -            if (node.finalizer != null) {
  22.419 -                return getEndPos(node.finalizer, endPositions);
  22.420 -            } else if (!node.catchers.isEmpty()) {
  22.421 -                return getEndPos(node.catchers.last(), endPositions);
  22.422 -            } else {
  22.423 -                return getEndPos(node.body, endPositions);
  22.424 +            case LABELLED:
  22.425 +                return getEndPos(((JCLabeledStatement) tree).body, endPositions);
  22.426 +            case MODIFIERS:
  22.427 +                return getEndPos(((JCModifiers) tree).annotations.last(), endPositions);
  22.428 +            case SYNCHRONIZED:
  22.429 +                return getEndPos(((JCSynchronized) tree).body, endPositions);
  22.430 +            case TOPLEVEL:
  22.431 +                return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions);
  22.432 +            case TRY: {
  22.433 +                JCTry node = (JCTry)tree;
  22.434 +                if (node.finalizer != null) {
  22.435 +                    return getEndPos(node.finalizer, endPositions);
  22.436 +                } else if (!node.catchers.isEmpty()) {
  22.437 +                    return getEndPos(node.catchers.last(), endPositions);
  22.438 +                } else {
  22.439 +                    return getEndPos(node.body, endPositions);
  22.440 +                }
  22.441              }
  22.442 -        }
  22.443 -        case(JCTree.WILDCARD):
  22.444 -            return getEndPos(((JCWildcard) tree).inner, endPositions);
  22.445 -        case(JCTree.TYPECAST):
  22.446 -            return getEndPos(((JCTypeCast) tree).expr, endPositions);
  22.447 -        case(JCTree.TYPETEST):
  22.448 -            return getEndPos(((JCInstanceOf) tree).clazz, endPositions);
  22.449 -        case(JCTree.POS):
  22.450 -        case(JCTree.NEG):
  22.451 -        case(JCTree.NOT):
  22.452 -        case(JCTree.COMPL):
  22.453 -        case(JCTree.PREINC):
  22.454 -        case(JCTree.PREDEC):
  22.455 -            return getEndPos(((JCUnary) tree).arg, endPositions);
  22.456 -        case(JCTree.WHILELOOP):
  22.457 -            return getEndPos(((JCWhileLoop) tree).body, endPositions);
  22.458 -        case(JCTree.ERRONEOUS): {
  22.459 -            JCErroneous node = (JCErroneous)tree;
  22.460 -            if (node.errs != null && node.errs.nonEmpty())
  22.461 -                return getEndPos(node.errs.last(), endPositions);
  22.462 -        }
  22.463 +            case WILDCARD:
  22.464 +                return getEndPos(((JCWildcard) tree).inner, endPositions);
  22.465 +            case TYPECAST:
  22.466 +                return getEndPos(((JCTypeCast) tree).expr, endPositions);
  22.467 +            case TYPETEST:
  22.468 +                return getEndPos(((JCInstanceOf) tree).clazz, endPositions);
  22.469 +            case POS:
  22.470 +            case NEG:
  22.471 +            case NOT:
  22.472 +            case COMPL:
  22.473 +            case PREINC:
  22.474 +            case PREDEC:
  22.475 +                return getEndPos(((JCUnary) tree).arg, endPositions);
  22.476 +            case WHILELOOP:
  22.477 +                return getEndPos(((JCWhileLoop) tree).body, endPositions);
  22.478 +            case ERRONEOUS: {
  22.479 +                JCErroneous node = (JCErroneous)tree;
  22.480 +                if (node.errs != null && node.errs.nonEmpty())
  22.481 +                    return getEndPos(node.errs.last(), endPositions);
  22.482 +            }
  22.483          }
  22.484          return Position.NOPOS;
  22.485      }
  22.486 @@ -443,11 +453,11 @@
  22.487      /** The position of the finalizer of given try/synchronized statement.
  22.488       */
  22.489      public static int finalizerPos(JCTree tree) {
  22.490 -        if (tree.getTag() == JCTree.TRY) {
  22.491 +        if (tree.hasTag(TRY)) {
  22.492              JCTry t = (JCTry) tree;
  22.493              Assert.checkNonNull(t.finalizer);
  22.494              return firstStatPos(t.finalizer);
  22.495 -        } else if (tree.getTag() == JCTree.SYNCHRONIZED) {
  22.496 +        } else if (tree.hasTag(SYNCHRONIZED)) {
  22.497              return endPos(((JCSynchronized) tree).body);
  22.498          } else {
  22.499              throw new AssertionError();
  22.500 @@ -547,9 +557,9 @@
  22.501      public static JCTree referencedStatement(JCLabeledStatement tree) {
  22.502          JCTree t = tree;
  22.503          do t = ((JCLabeledStatement) t).body;
  22.504 -        while (t.getTag() == JCTree.LABELLED);
  22.505 +        while (t.hasTag(LABELLED));
  22.506          switch (t.getTag()) {
  22.507 -        case JCTree.DOLOOP: case JCTree.WHILELOOP: case JCTree.FORLOOP: case JCTree.FOREACHLOOP: case JCTree.SWITCH:
  22.508 +        case DOLOOP: case WHILELOOP: case FORLOOP: case FOREACHLOOP: case SWITCH:
  22.509              return t;
  22.510          default:
  22.511              return tree;
  22.512 @@ -559,7 +569,7 @@
  22.513      /** Skip parens and return the enclosed expression
  22.514       */
  22.515      public static JCExpression skipParens(JCExpression tree) {
  22.516 -        while (tree.getTag() == JCTree.PARENS) {
  22.517 +        while (tree.hasTag(PARENS)) {
  22.518              tree = ((JCParens) tree).expr;
  22.519          }
  22.520          return tree;
  22.521 @@ -568,7 +578,7 @@
  22.522      /** Skip parens and return the enclosed expression
  22.523       */
  22.524      public static JCTree skipParens(JCTree tree) {
  22.525 -        if (tree.getTag() == JCTree.PARENS)
  22.526 +        if (tree.hasTag(PARENS))
  22.527              return skipParens((JCParens)tree);
  22.528          else
  22.529              return tree;
  22.530 @@ -588,11 +598,11 @@
  22.531       */
  22.532      public static Name name(JCTree tree) {
  22.533          switch (tree.getTag()) {
  22.534 -        case JCTree.IDENT:
  22.535 +        case IDENT:
  22.536              return ((JCIdent) tree).name;
  22.537 -        case JCTree.SELECT:
  22.538 +        case SELECT:
  22.539              return ((JCFieldAccess) tree).name;
  22.540 -        case JCTree.TYPEAPPLY:
  22.541 +        case TYPEAPPLY:
  22.542              return name(((JCTypeApply) tree).clazz);
  22.543          default:
  22.544              return null;
  22.545 @@ -605,9 +615,9 @@
  22.546      public static Name fullName(JCTree tree) {
  22.547          tree = skipParens(tree);
  22.548          switch (tree.getTag()) {
  22.549 -        case JCTree.IDENT:
  22.550 +        case IDENT:
  22.551              return ((JCIdent) tree).name;
  22.552 -        case JCTree.SELECT:
  22.553 +        case SELECT:
  22.554              Name sname = fullName(((JCFieldAccess) tree).selected);
  22.555              return sname == null ? null : sname.append('.', name(tree));
  22.556          default:
  22.557 @@ -618,11 +628,11 @@
  22.558      public static Symbol symbolFor(JCTree node) {
  22.559          node = skipParens(node);
  22.560          switch (node.getTag()) {
  22.561 -        case JCTree.CLASSDEF:
  22.562 +        case CLASSDEF:
  22.563              return ((JCClassDecl) node).sym;
  22.564 -        case JCTree.METHODDEF:
  22.565 +        case METHODDEF:
  22.566              return ((JCMethodDecl) node).sym;
  22.567 -        case JCTree.VARDEF:
  22.568 +        case VARDEF:
  22.569              return ((JCVariableDecl) node).sym;
  22.570          default:
  22.571              return null;
  22.572 @@ -632,9 +642,9 @@
  22.573      public static boolean isDeclaration(JCTree node) {
  22.574          node = skipParens(node);
  22.575          switch (node.getTag()) {
  22.576 -        case JCTree.CLASSDEF:
  22.577 -        case JCTree.METHODDEF:
  22.578 -        case JCTree.VARDEF:
  22.579 +        case CLASSDEF:
  22.580 +        case METHODDEF:
  22.581 +        case VARDEF:
  22.582              return true;
  22.583          default:
  22.584              return false;
  22.585 @@ -647,11 +657,11 @@
  22.586      public static Symbol symbol(JCTree tree) {
  22.587          tree = skipParens(tree);
  22.588          switch (tree.getTag()) {
  22.589 -        case JCTree.IDENT:
  22.590 +        case IDENT:
  22.591              return ((JCIdent) tree).sym;
  22.592 -        case JCTree.SELECT:
  22.593 +        case SELECT:
  22.594              return ((JCFieldAccess) tree).sym;
  22.595 -        case JCTree.TYPEAPPLY:
  22.596 +        case TYPEAPPLY:
  22.597              return symbol(((JCTypeApply) tree).clazz);
  22.598          default:
  22.599              return null;
  22.600 @@ -661,7 +671,7 @@
  22.601      /** Return true if this is a nonstatic selection. */
  22.602      public static boolean nonstaticSelect(JCTree tree) {
  22.603          tree = skipParens(tree);
  22.604 -        if (tree.getTag() != JCTree.SELECT) return false;
  22.605 +        if (!tree.hasTag(SELECT)) return false;
  22.606          JCFieldAccess s = (JCFieldAccess) tree;
  22.607          Symbol e = symbol(s.selected);
  22.608          return e == null || (e.kind != Kinds.PCK && e.kind != Kinds.TYP);
  22.609 @@ -672,9 +682,9 @@
  22.610      public static void setSymbol(JCTree tree, Symbol sym) {
  22.611          tree = skipParens(tree);
  22.612          switch (tree.getTag()) {
  22.613 -        case JCTree.IDENT:
  22.614 +        case IDENT:
  22.615              ((JCIdent) tree).sym = sym; break;
  22.616 -        case JCTree.SELECT:
  22.617 +        case SELECT:
  22.618              ((JCFieldAccess) tree).sym = sym; break;
  22.619          default:
  22.620          }
  22.621 @@ -685,13 +695,13 @@
  22.622       */
  22.623      public static long flags(JCTree tree) {
  22.624          switch (tree.getTag()) {
  22.625 -        case JCTree.VARDEF:
  22.626 +        case VARDEF:
  22.627              return ((JCVariableDecl) tree).mods.flags;
  22.628 -        case JCTree.METHODDEF:
  22.629 +        case METHODDEF:
  22.630              return ((JCMethodDecl) tree).mods.flags;
  22.631 -        case JCTree.CLASSDEF:
  22.632 +        case CLASSDEF:
  22.633              return ((JCClassDecl) tree).mods.flags;
  22.634 -        case JCTree.BLOCK:
  22.635 +        case BLOCK:
  22.636              return ((JCBlock) tree).flags;
  22.637          default:
  22.638              return 0;
  22.639 @@ -739,155 +749,155 @@
  22.640  
  22.641      /** Map operators to their precedence levels.
  22.642       */
  22.643 -    public static int opPrec(int op) {
  22.644 +    public static int opPrec(JCTree.Tag op) {
  22.645          switch(op) {
  22.646 -        case JCTree.POS:
  22.647 -        case JCTree.NEG:
  22.648 -        case JCTree.NOT:
  22.649 -        case JCTree.COMPL:
  22.650 -        case JCTree.PREINC:
  22.651 -        case JCTree.PREDEC: return prefixPrec;
  22.652 -        case JCTree.POSTINC:
  22.653 -        case JCTree.POSTDEC:
  22.654 -        case JCTree.NULLCHK: return postfixPrec;
  22.655 -        case JCTree.ASSIGN: return assignPrec;
  22.656 -        case JCTree.BITOR_ASG:
  22.657 -        case JCTree.BITXOR_ASG:
  22.658 -        case JCTree.BITAND_ASG:
  22.659 -        case JCTree.SL_ASG:
  22.660 -        case JCTree.SR_ASG:
  22.661 -        case JCTree.USR_ASG:
  22.662 -        case JCTree.PLUS_ASG:
  22.663 -        case JCTree.MINUS_ASG:
  22.664 -        case JCTree.MUL_ASG:
  22.665 -        case JCTree.DIV_ASG:
  22.666 -        case JCTree.MOD_ASG: return assignopPrec;
  22.667 -        case JCTree.OR: return orPrec;
  22.668 -        case JCTree.AND: return andPrec;
  22.669 -        case JCTree.EQ:
  22.670 -        case JCTree.NE: return eqPrec;
  22.671 -        case JCTree.LT:
  22.672 -        case JCTree.GT:
  22.673 -        case JCTree.LE:
  22.674 -        case JCTree.GE: return ordPrec;
  22.675 -        case JCTree.BITOR: return bitorPrec;
  22.676 -        case JCTree.BITXOR: return bitxorPrec;
  22.677 -        case JCTree.BITAND: return bitandPrec;
  22.678 -        case JCTree.SL:
  22.679 -        case JCTree.SR:
  22.680 -        case JCTree.USR: return shiftPrec;
  22.681 -        case JCTree.PLUS:
  22.682 -        case JCTree.MINUS: return addPrec;
  22.683 -        case JCTree.MUL:
  22.684 -        case JCTree.DIV:
  22.685 -        case JCTree.MOD: return mulPrec;
  22.686 -        case JCTree.TYPETEST: return ordPrec;
  22.687 +        case POS:
  22.688 +        case NEG:
  22.689 +        case NOT:
  22.690 +        case COMPL:
  22.691 +        case PREINC:
  22.692 +        case PREDEC: return prefixPrec;
  22.693 +        case POSTINC:
  22.694 +        case POSTDEC:
  22.695 +        case NULLCHK: return postfixPrec;
  22.696 +        case ASSIGN: return assignPrec;
  22.697 +        case BITOR_ASG:
  22.698 +        case BITXOR_ASG:
  22.699 +        case BITAND_ASG:
  22.700 +        case SL_ASG:
  22.701 +        case SR_ASG:
  22.702 +        case USR_ASG:
  22.703 +        case PLUS_ASG:
  22.704 +        case MINUS_ASG:
  22.705 +        case MUL_ASG:
  22.706 +        case DIV_ASG:
  22.707 +        case MOD_ASG: return assignopPrec;
  22.708 +        case OR: return orPrec;
  22.709 +        case AND: return andPrec;
  22.710 +        case EQ:
  22.711 +        case NE: return eqPrec;
  22.712 +        case LT:
  22.713 +        case GT:
  22.714 +        case LE:
  22.715 +        case GE: return ordPrec;
  22.716 +        case BITOR: return bitorPrec;
  22.717 +        case BITXOR: return bitxorPrec;
  22.718 +        case BITAND: return bitandPrec;
  22.719 +        case SL:
  22.720 +        case SR:
  22.721 +        case USR: return shiftPrec;
  22.722 +        case PLUS:
  22.723 +        case MINUS: return addPrec;
  22.724 +        case MUL:
  22.725 +        case DIV:
  22.726 +        case MOD: return mulPrec;
  22.727 +        case TYPETEST: return ordPrec;
  22.728          default: throw new AssertionError();
  22.729          }
  22.730      }
  22.731  
  22.732 -    static Tree.Kind tagToKind(int tag) {
  22.733 +    static Tree.Kind tagToKind(JCTree.Tag tag) {
  22.734          switch (tag) {
  22.735          // Postfix expressions
  22.736 -        case JCTree.POSTINC:           // _ ++
  22.737 +        case POSTINC:           // _ ++
  22.738              return Tree.Kind.POSTFIX_INCREMENT;
  22.739 -        case JCTree.POSTDEC:           // _ --
  22.740 +        case POSTDEC:           // _ --
  22.741              return Tree.Kind.POSTFIX_DECREMENT;
  22.742  
  22.743          // Unary operators
  22.744 -        case JCTree.PREINC:            // ++ _
  22.745 +        case PREINC:            // ++ _
  22.746              return Tree.Kind.PREFIX_INCREMENT;
  22.747 -        case JCTree.PREDEC:            // -- _
  22.748 +        case PREDEC:            // -- _
  22.749              return Tree.Kind.PREFIX_DECREMENT;
  22.750 -        case JCTree.POS:               // +
  22.751 +        case POS:               // +
  22.752              return Tree.Kind.UNARY_PLUS;
  22.753 -        case JCTree.NEG:               // -
  22.754 +        case NEG:               // -
  22.755              return Tree.Kind.UNARY_MINUS;
  22.756 -        case JCTree.COMPL:             // ~
  22.757 +        case COMPL:             // ~
  22.758              return Tree.Kind.BITWISE_COMPLEMENT;
  22.759 -        case JCTree.NOT:               // !
  22.760 +        case NOT:               // !
  22.761              return Tree.Kind.LOGICAL_COMPLEMENT;
  22.762  
  22.763          // Binary operators
  22.764  
  22.765          // Multiplicative operators
  22.766 -        case JCTree.MUL:               // *
  22.767 +        case MUL:               // *
  22.768              return Tree.Kind.MULTIPLY;
  22.769 -        case JCTree.DIV:               // /
  22.770 +        case DIV:               // /
  22.771              return Tree.Kind.DIVIDE;
  22.772 -        case JCTree.MOD:               // %
  22.773 +        case MOD:               // %
  22.774              return Tree.Kind.REMAINDER;
  22.775  
  22.776          // Additive operators
  22.777 -        case JCTree.PLUS:              // +
  22.778 +        case PLUS:              // +
  22.779              return Tree.Kind.PLUS;
  22.780 -        case JCTree.MINUS:             // -
  22.781 +        case MINUS:             // -
  22.782              return Tree.Kind.MINUS;
  22.783  
  22.784          // Shift operators
  22.785 -        case JCTree.SL:                // <<
  22.786 +        case SL:                // <<
  22.787              return Tree.Kind.LEFT_SHIFT;
  22.788 -        case JCTree.SR:                // >>
  22.789 +        case SR:                // >>
  22.790              return Tree.Kind.RIGHT_SHIFT;
  22.791 -        case JCTree.USR:               // >>>
  22.792 +        case USR:               // >>>
  22.793              return Tree.Kind.UNSIGNED_RIGHT_SHIFT;
  22.794  
  22.795          // Relational operators
  22.796 -        case JCTree.LT:                // <
  22.797 +        case LT:                // <
  22.798              return Tree.Kind.LESS_THAN;
  22.799 -        case JCTree.GT:                // >
  22.800 +        case GT:                // >
  22.801              return Tree.Kind.GREATER_THAN;
  22.802 -        case JCTree.LE:                // <=
  22.803 +        case LE:                // <=
  22.804              return Tree.Kind.LESS_THAN_EQUAL;
  22.805 -        case JCTree.GE:                // >=
  22.806 +        case GE:                // >=
  22.807              return Tree.Kind.GREATER_THAN_EQUAL;
  22.808  
  22.809          // Equality operators
  22.810 -        case JCTree.EQ:                // ==
  22.811 +        case EQ:                // ==
  22.812              return Tree.Kind.EQUAL_TO;
  22.813 -        case JCTree.NE:                // !=
  22.814 +        case NE:                // !=
  22.815              return Tree.Kind.NOT_EQUAL_TO;
  22.816  
  22.817          // Bitwise and logical operators
  22.818 -        case JCTree.BITAND:            // &
  22.819 +        case BITAND:            // &
  22.820              return Tree.Kind.AND;
  22.821 -        case JCTree.BITXOR:            // ^
  22.822 +        case BITXOR:            // ^
  22.823              return Tree.Kind.XOR;
  22.824 -        case JCTree.BITOR:             // |
  22.825 +        case BITOR:             // |
  22.826              return Tree.Kind.OR;
  22.827  
  22.828          // Conditional operators
  22.829 -        case JCTree.AND:               // &&
  22.830 +        case AND:               // &&
  22.831              return Tree.Kind.CONDITIONAL_AND;
  22.832 -        case JCTree.OR:                // ||
  22.833 +        case OR:                // ||
  22.834              return Tree.Kind.CONDITIONAL_OR;
  22.835  
  22.836          // Assignment operators
  22.837 -        case JCTree.MUL_ASG:           // *=
  22.838 +        case MUL_ASG:           // *=
  22.839              return Tree.Kind.MULTIPLY_ASSIGNMENT;
  22.840 -        case JCTree.DIV_ASG:           // /=
  22.841 +        case DIV_ASG:           // /=
  22.842              return Tree.Kind.DIVIDE_ASSIGNMENT;
  22.843 -        case JCTree.MOD_ASG:           // %=
  22.844 +        case MOD_ASG:           // %=
  22.845              return Tree.Kind.REMAINDER_ASSIGNMENT;
  22.846 -        case JCTree.PLUS_ASG:          // +=
  22.847 +        case PLUS_ASG:          // +=
  22.848              return Tree.Kind.PLUS_ASSIGNMENT;
  22.849 -        case JCTree.MINUS_ASG:         // -=
  22.850 +        case MINUS_ASG:         // -=
  22.851              return Tree.Kind.MINUS_ASSIGNMENT;
  22.852 -        case JCTree.SL_ASG:            // <<=
  22.853 +        case SL_ASG:            // <<=
  22.854              return Tree.Kind.LEFT_SHIFT_ASSIGNMENT;
  22.855 -        case JCTree.SR_ASG:            // >>=
  22.856 +        case SR_ASG:            // >>=
  22.857              return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT;
  22.858 -        case JCTree.USR_ASG:           // >>>=
  22.859 +        case USR_ASG:           // >>>=
  22.860              return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT;
  22.861 -        case JCTree.BITAND_ASG:        // &=
  22.862 +        case BITAND_ASG:        // &=
  22.863              return Tree.Kind.AND_ASSIGNMENT;
  22.864 -        case JCTree.BITXOR_ASG:        // ^=
  22.865 +        case BITXOR_ASG:        // ^=
  22.866              return Tree.Kind.XOR_ASSIGNMENT;
  22.867 -        case JCTree.BITOR_ASG:         // |=
  22.868 +        case BITOR_ASG:         // |=
  22.869              return Tree.Kind.OR_ASSIGNMENT;
  22.870  
  22.871          // Null check (implementation detail), for example, __.getClass()
  22.872 -        case JCTree.NULLCHK:
  22.873 +        case NULLCHK:
  22.874              return Tree.Kind.OTHER;
  22.875  
  22.876          default:
  22.877 @@ -901,13 +911,13 @@
  22.878       */
  22.879      public static JCExpression typeIn(JCExpression tree) {
  22.880          switch (tree.getTag()) {
  22.881 -        case JCTree.IDENT: /* simple names */
  22.882 -        case JCTree.TYPEIDENT: /* primitive name */
  22.883 -        case JCTree.SELECT: /* qualified name */
  22.884 -        case JCTree.TYPEARRAY: /* array types */
  22.885 -        case JCTree.WILDCARD: /* wild cards */
  22.886 -        case JCTree.TYPEPARAMETER: /* type parameters */
  22.887 -        case JCTree.TYPEAPPLY: /* parameterized types */
  22.888 +        case IDENT: /* simple names */
  22.889 +        case TYPEIDENT: /* primitive name */
  22.890 +        case SELECT: /* qualified name */
  22.891 +        case TYPEARRAY: /* array types */
  22.892 +        case WILDCARD: /* wild cards */
  22.893 +        case TYPEPARAMETER: /* type parameters */
  22.894 +        case TYPEAPPLY: /* parameterized types */
  22.895              return tree;
  22.896          default:
  22.897              throw new AssertionError("Unexpected type tree: " + tree);
  22.898 @@ -916,9 +926,9 @@
  22.899  
  22.900      public static JCTree innermostType(JCTree type) {
  22.901          switch (type.getTag()) {
  22.902 -        case JCTree.TYPEARRAY:
  22.903 +        case TYPEARRAY:
  22.904              return innermostType(((JCArrayTypeTree)type).elemtype);
  22.905 -        case JCTree.WILDCARD:
  22.906 +        case WILDCARD:
  22.907              return innermostType(((JCWildcard)type).inner);
  22.908          default:
  22.909              return type;