jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/comp/Annotate.java@f3ca12d680f3 (annotated)

src/share/classes/com/sun/tools/javac/comp/Annotate.java@f3ca12d680f3 (annotated)

src/share/classes/com/sun/tools/javac/comp/Annotate.java

Mon, 11 Nov 2013 17:26:09 +0100

author: jfranck
date: Mon, 11 Nov 2013 17:26:09 +0100
changeset 2188: f3ca12d680f3
parent 2136: 7f6481e5fe3a
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

8027375: javac asserts on nested erroneous annotations
Summary: make sure JCAnnotation trees have type != null before annotation processing
Reviewed-by: jjg

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.javac.comp;
 import java.util.Map;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.code.TypeTag.ARRAY;
 import static com.sun.tools.javac.code.TypeTag.CLASS;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 import javax.lang.model.type.ErrorType;
 /** Enter annotations on symbols.  Annotations accumulate in a queue,
  *  which is processed at the top level of any set of recursive calls
  *  requesting it be processed.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class Annotate {
     protected static final Context.Key<Annotate> annotateKey =
         new Context.Key<Annotate>();
     public static Annotate instance(Context context) {
         Annotate instance = context.get(annotateKey);
         if (instance == null)
             instance = new Annotate(context);
         return instance;
     }
     final Attr attr;
     final TreeMaker make;
     final Log log;
     final Symtab syms;
     final Names names;
     final Resolve rs;
     final Types types;
     final ConstFold cfolder;
     final Check chk;
     protected Annotate(Context context) {
         context.put(annotateKey, this);
         attr = Attr.instance(context);
         make = TreeMaker.instance(context);
         log = Log.instance(context);
         syms = Symtab.instance(context);
         names = Names.instance(context);
         rs = Resolve.instance(context);
         types = Types.instance(context);
         cfolder = ConstFold.instance(context);
         chk = Check.instance(context);
     }
 /* ********************************************************************
  * Queue maintenance
  *********************************************************************/
     private int enterCount = 0;
     ListBuffer<Worker> q = new ListBuffer<Worker>();
     ListBuffer<Worker> typesQ = new ListBuffer<Worker>();
     ListBuffer<Worker> repeatedQ = new ListBuffer<Worker>();
     ListBuffer<Worker> afterRepeatedQ = new ListBuffer<Worker>();
     ListBuffer<Worker> validateQ = new ListBuffer<Worker>();
     public void earlier(Worker a) {
         q.prepend(a);
     }
     public void normal(Worker a) {
         q.append(a);
     }
     public void typeAnnotation(Worker a) {
         typesQ.append(a);
     }
     public void repeated(Worker a) {
         repeatedQ.append(a);
     }
     public void afterRepeated(Worker a) {
         afterRepeatedQ.append(a);
     }
     public void validate(Worker a) {
         validateQ.append(a);
     }
     /** Called when the Enter phase starts. */
     public void enterStart() {
         enterCount++;
     }
     /** Called after the Enter phase completes. */
     public void enterDone() {
         enterCount--;
         flush();
     }
     /** Variant which allows for a delayed flush of annotations.
      * Needed by ClassReader */
     public void enterDoneWithoutFlush() {
         enterCount--;
     }
     public void flush() {
         if (enterCount != 0) return;
         enterCount++;
         try {
             while (q.nonEmpty()) {
                 q.next().run();
             }
             while (typesQ.nonEmpty()) {
                 typesQ.next().run();
             }
             while (repeatedQ.nonEmpty()) {
                 repeatedQ.next().run();
             }
             while (afterRepeatedQ.nonEmpty()) {
                 afterRepeatedQ.next().run();
             }
             while (validateQ.nonEmpty()) {
                 validateQ.next().run();
             }
         } finally {
             enterCount--;
         }
     }
     /** A client that needs to run during {@link #flush()} registers an worker
      *  into one of the queues defined in this class. The queues are: {@link #earlier(Worker)},
      *  {@link #normal(Worker)}, {@link #typeAnnotation(Worker)}, {@link #repeated(Worker)},
      *  {@link #afterRepeated(Worker)}, {@link #validate(Worker)}.
      *  The {@link Worker#run()} method will called inside the {@link #flush()}
      *  call. Queues are empties in the abovementioned order.
      */
     public interface Worker {
         void run();
         String toString();
     }
     /**
      * This context contains all the information needed to synthesize new
      * annotations trees by the completer for repeating annotations.
      */
     public class AnnotateRepeatedContext<T extends Attribute.Compound> {
         public final Env<AttrContext> env;
         public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;
         public final Map<T, JCDiagnostic.DiagnosticPosition> pos;
         public final Log log;
         public final boolean isTypeCompound;
         public AnnotateRepeatedContext(Env<AttrContext> env,
                                        Map<Symbol.TypeSymbol, ListBuffer<T>> annotated,
                                        Map<T, JCDiagnostic.DiagnosticPosition> pos,
                                        Log log,
                                        boolean isTypeCompound) {
             Assert.checkNonNull(env);
             Assert.checkNonNull(annotated);
             Assert.checkNonNull(pos);
             Assert.checkNonNull(log);
             this.env = env;
             this.annotated = annotated;
             this.pos = pos;
             this.log = log;
             this.isTypeCompound = isTypeCompound;
         }
         /**
          * Process a list of repeating annotations returning a new
          * Attribute.Compound that is the attribute for the synthesized tree
          * for the container.
          *
          * @param repeatingAnnotations a List of repeating annotations
          * @return a new Attribute.Compound that is the container for the repeatingAnnotations
          */
         public T processRepeatedAnnotations(List<T> repeatingAnnotations, Symbol sym) {
             return Annotate.this.processRepeatedAnnotations(repeatingAnnotations, this, sym);
         }
         /**
          * Queue the Worker a on the repeating annotations queue of the
          * Annotate instance this context belongs to.
          *
          * @param a the Worker to enqueue for repeating annotation annotating
          */
         public void annotateRepeated(Worker a) {
             Annotate.this.repeated(a);
         }
     }
 /* ********************************************************************
  * Compute an attribute from its annotation.
  *********************************************************************/
     /** Process a single compound annotation, returning its
      *  Attribute. Used from MemberEnter for attaching the attributes
      *  to the annotated symbol.
      */
     Attribute.Compound enterAnnotation(JCAnnotation a,
                                        Type expected,
                                        Env<AttrContext> env) {
         return enterAnnotation(a, expected, env, false);
     }
     Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,
             Type expected,
             Env<AttrContext> env) {
         return (Attribute.TypeCompound) enterAnnotation(a, expected, env, true);
     }
     // boolean typeAnnotation determines whether the method returns
     // a Compound (false) or TypeCompound (true).
     Attribute.Compound enterAnnotation(JCAnnotation a,
             Type expected,
             Env<AttrContext> env,
             boolean typeAnnotation) {
         // The annotation might have had its type attributed (but not checked)
         // by attr.attribAnnotationTypes during MemberEnter, in which case we do not
         // need to do it again.
         Type at = (a.annotationType.type != null ? a.annotationType.type
                   : attr.attribType(a.annotationType, env));
         a.type = chk.checkType(a.annotationType.pos(), at, expected);
         if (a.type.isErroneous()) {
             // Need to make sure nested (anno)trees does not have null as .type
             attr.postAttr(a);
             if (typeAnnotation) {
                 return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(),
                         new TypeAnnotationPosition());
             } else {
                 return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
             }
         }
         if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0) {
             log.error(a.annotationType.pos(),
                       "not.annotation.type", a.type.toString());
             // Need to make sure nested (anno)trees does not have null as .type
             attr.postAttr(a);
             if (typeAnnotation) {
                 return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
             } else {
                 return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
             }
         }
         List<JCExpression> args = a.args;
         if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {
             // special case: elided "value=" assumed
             args.head = make.at(args.head.pos).
                 Assign(make.Ident(names.value), args.head);
         }
         ListBuffer<Pair<MethodSymbol,Attribute>> buf =
             new ListBuffer<>();
         for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {
             JCExpression t = tl.head;
             if (!t.hasTag(ASSIGN)) {
                 log.error(t.pos(), "annotation.value.must.be.name.value");
                 continue;
             }
             JCAssign assign = (JCAssign)t;
             if (!assign.lhs.hasTag(IDENT)) {
                 log.error(t.pos(), "annotation.value.must.be.name.value");
                 continue;
             }
             JCIdent left = (JCIdent)assign.lhs;
             Symbol method = rs.resolveQualifiedMethod(assign.rhs.pos(),
                                                           env,
                                                           a.type,
                                                           left.name,
                                                           List.<Type>nil(),
                                                           null);
             left.sym = method;
             left.type = method.type;
             if (method.owner != a.type.tsym)
                 log.error(left.pos(), "no.annotation.member", left.name, a.type);
             Type result = method.type.getReturnType();
             Attribute value = enterAttributeValue(result, assign.rhs, env);
             if (!method.type.isErroneous())
                 buf.append(new Pair<>((MethodSymbol)method, value));
             t.type = result;
         }
         if (typeAnnotation) {
             if (a.attribute == null || !(a.attribute instanceof Attribute.TypeCompound)) {
                 // Create a new TypeCompound
                 Attribute.TypeCompound tc = new Attribute.TypeCompound(a.type, buf.toList(), new TypeAnnotationPosition());
                 a.attribute = tc;
                 return tc;
             } else {
                 // Use an existing TypeCompound
                 return a.attribute;
             }
         } else {
             Attribute.Compound ac = new Attribute.Compound(a.type, buf.toList());
             a.attribute = ac;
             return ac;
         }
     }
     Attribute enterAttributeValue(Type expected,
                                   JCExpression tree,
                                   Env<AttrContext> env) {
         //first, try completing the attribution value sym - if a completion
         //error is thrown, we should recover gracefully, and display an
         //ordinary resolution diagnostic.
         try {
             expected.tsym.complete();
         } catch(CompletionFailure e) {
             log.error(tree.pos(), "cant.resolve", Kinds.kindName(e.sym), e.sym);
             expected = syms.errType;
         }
         if (expected.hasTag(ARRAY)) {
             if (!tree.hasTag(NEWARRAY)) {
                 tree = make.at(tree.pos).
                     NewArray(null, List.<JCExpression>nil(), List.of(tree));
             }
             JCNewArray na = (JCNewArray)tree;
             if (na.elemtype != null) {
                 log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");
             }
             ListBuffer<Attribute> buf = new ListBuffer<Attribute>();
             for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
                 buf.append(enterAttributeValue(types.elemtype(expected),
                                                l.head,
                                                env));
             }
             na.type = expected;
             return new Attribute.
                 Array(expected, buf.toArray(new Attribute[buf.length()]));
         }
         if (tree.hasTag(NEWARRAY)) { //error recovery
             if (!expected.isErroneous())
                 log.error(tree.pos(), "annotation.value.not.allowable.type");
             JCNewArray na = (JCNewArray)tree;
             if (na.elemtype != null) {
                 log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");
             }
             for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
                 enterAttributeValue(syms.errType,
                                     l.head,
                                     env);
             }
             return new Attribute.Error(syms.errType);
         }
         if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {
             if (tree.hasTag(ANNOTATION)) {
                 return enterAnnotation((JCAnnotation)tree, expected, env);
             } else {
                 log.error(tree.pos(), "annotation.value.must.be.annotation");
                 expected = syms.errType;
             }
         }
         if (tree.hasTag(ANNOTATION)) { //error recovery
             if (!expected.isErroneous())
                 log.error(tree.pos(), "annotation.not.valid.for.type", expected);
             enterAnnotation((JCAnnotation)tree, syms.errType, env);
             return new Attribute.Error(((JCAnnotation)tree).annotationType.type);
         }
         if (expected.isPrimitive() || types.isSameType(expected, syms.stringType)) {
             Type result = attr.attribExpr(tree, env, expected);
             if (result.isErroneous())
                 return new Attribute.Error(result.getOriginalType());
             if (result.constValue() == null) {
                 log.error(tree.pos(), "attribute.value.must.be.constant");
                 return new Attribute.Error(expected);
             }
             result = cfolder.coerce(result, expected);
             return new Attribute.Constant(expected, result.constValue());
         }
         if (expected.tsym == syms.classType.tsym) {
             Type result = attr.attribExpr(tree, env, expected);
             if (result.isErroneous()) {
                 // Does it look like an unresolved class literal?
                 if (TreeInfo.name(tree) == names._class &&
                     ((JCFieldAccess) tree).selected.type.isErroneous()) {
                     Name n = (((JCFieldAccess) tree).selected).type.tsym.flatName();
                     return new Attribute.UnresolvedClass(expected,
                             types.createErrorType(n,
                                     syms.unknownSymbol, syms.classType));
                 } else {
                     return new Attribute.Error(result.getOriginalType());
                 }
             }
             // Class literals look like field accesses of a field named class
             // at the tree level
             if (TreeInfo.name(tree) != names._class) {
                 log.error(tree.pos(), "annotation.value.must.be.class.literal");
                 return new Attribute.Error(syms.errType);
             }
             return new Attribute.Class(types,
                                        (((JCFieldAccess) tree).selected).type);
         }
         if (expected.hasTag(CLASS) &&
             (expected.tsym.flags() & Flags.ENUM) != 0) {
             Type result = attr.attribExpr(tree, env, expected);
             Symbol sym = TreeInfo.symbol(tree);
             if (sym == null ||
                 TreeInfo.nonstaticSelect(tree) ||
                 sym.kind != Kinds.VAR ||
                 (sym.flags() & Flags.ENUM) == 0) {
                 log.error(tree.pos(), "enum.annotation.must.be.enum.constant");
                 return new Attribute.Error(result.getOriginalType());
             }
             VarSymbol enumerator = (VarSymbol) sym;
             return new Attribute.Enum(expected, enumerator);
         }
         //error recovery:
         if (!expected.isErroneous())
             log.error(tree.pos(), "annotation.value.not.allowable.type");
         return new Attribute.Error(attr.attribExpr(tree, env, expected));
     }
     /* *********************************
      * Support for repeating annotations
      ***********************************/
     /* Process repeated annotations. This method returns the
      * synthesized container annotation or null IFF all repeating
      * annotation are invalid.  This method reports errors/warnings.
      */
     private <T extends Attribute.Compound> T processRepeatedAnnotations(List<T> annotations,
             AnnotateRepeatedContext<T> ctx,
             Symbol on) {
         T firstOccurrence = annotations.head;
         List<Attribute> repeated = List.nil();
         Type origAnnoType = null;
         Type arrayOfOrigAnnoType = null;
         Type targetContainerType = null;
         MethodSymbol containerValueSymbol = null;
         Assert.check(!annotations.isEmpty() &&
                      !annotations.tail.isEmpty()); // i.e. size() > 1
         int count = 0;
         for (List<T> al = annotations;
              !al.isEmpty();
              al = al.tail)
         {
             count++;
             // There must be more than a single anno in the annotation list
             Assert.check(count > 1 || !al.tail.isEmpty());
             T currentAnno = al.head;
             origAnnoType = currentAnno.type;
             if (arrayOfOrigAnnoType == null) {
                 arrayOfOrigAnnoType = types.makeArrayType(origAnnoType);
             }
             // Only report errors if this isn't the first occurrence I.E. count > 1
             boolean reportError = count > 1;
             Type currentContainerType = getContainingType(currentAnno, ctx.pos.get(currentAnno), reportError);
             if (currentContainerType == null) {
                 continue;
             }
             // Assert that the target Container is == for all repeated
             // annos of the same annotation type, the types should
             // come from the same Symbol, i.e. be '=='
             Assert.check(targetContainerType == null || currentContainerType == targetContainerType);
             targetContainerType = currentContainerType;
             containerValueSymbol = validateContainer(targetContainerType, origAnnoType, ctx.pos.get(currentAnno));
             if (containerValueSymbol == null) { // Check of CA type failed
                 // errors are already reported
                 continue;
             }
             repeated = repeated.prepend(currentAnno);
         }
         if (!repeated.isEmpty()) {
             repeated = repeated.reverse();
             TreeMaker m = make.at(ctx.pos.get(firstOccurrence));
             Pair<MethodSymbol, Attribute> p =
                     new Pair<MethodSymbol, Attribute>(containerValueSymbol,
                                                       new Attribute.Array(arrayOfOrigAnnoType, repeated));
             if (ctx.isTypeCompound) {
                 /* TODO: the following code would be cleaner:
                 Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
                         ((Attribute.TypeCompound)annotations.head).position);
                 JCTypeAnnotation annoTree = m.TypeAnnotation(at);
                 at = enterTypeAnnotation(annoTree, targetContainerType, ctx.env);
                 */
                 // However, we directly construct the TypeCompound to keep the
                 // direct relation to the contained TypeCompounds.
                 Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
                         ((Attribute.TypeCompound)annotations.head).position);
                 // TODO: annotation applicability checks from below?
                 at.setSynthesized(true);
                 @SuppressWarnings("unchecked")
                 T x = (T) at;
                 return x;
             } else {
                 Attribute.Compound c = new Attribute.Compound(targetContainerType, List.of(p));
                 JCAnnotation annoTree = m.Annotation(c);
                 if (!chk.annotationApplicable(annoTree, on))
                     log.error(annoTree.pos(), "invalid.repeatable.annotation.incompatible.target", targetContainerType, origAnnoType);
                 if (!chk.validateAnnotationDeferErrors(annoTree))
                     log.error(annoTree.pos(), "duplicate.annotation.invalid.repeated", origAnnoType);
                 c = enterAnnotation(annoTree, targetContainerType, ctx.env);
                 c.setSynthesized(true);
                 @SuppressWarnings("unchecked")
                 T x = (T) c;
                 return x;
             }
         } else {
             return null; // errors should have been reported elsewhere
         }
     }
     /** Fetches the actual Type that should be the containing annotation. */
     private Type getContainingType(Attribute.Compound currentAnno,
             DiagnosticPosition pos,
             boolean reportError)
     {
         Type origAnnoType = currentAnno.type;
         TypeSymbol origAnnoDecl = origAnnoType.tsym;
         // Fetch the Repeatable annotation from the current
         // annotation's declaration, or null if it has none
         Attribute.Compound ca = origAnnoDecl.attribute(syms.repeatableType.tsym);
         if (ca == null) { // has no Repeatable annotation
             if (reportError)
                 log.error(pos, "duplicate.annotation.missing.container", origAnnoType, syms.repeatableType);
             return null;
         }
         return filterSame(extractContainingType(ca, pos, origAnnoDecl),
                           origAnnoType);
     }
     // returns null if t is same as 's', returns 't' otherwise
     private Type filterSame(Type t, Type s) {
         if (t == null || s == null) {
             return t;
         }
         return types.isSameType(t, s) ? null : t;
     }
     /** Extract the actual Type to be used for a containing annotation. */
     private Type extractContainingType(Attribute.Compound ca,
             DiagnosticPosition pos,
             TypeSymbol annoDecl)
     {
         // The next three checks check that the Repeatable annotation
         // on the declaration of the annotation type that is repeating is
         // valid.
         // Repeatable must have at least one element
         if (ca.values.isEmpty()) {
             log.error(pos, "invalid.repeatable.annotation", annoDecl);
             return null;
         }
         Pair<MethodSymbol,Attribute> p = ca.values.head;
         Name name = p.fst.name;
         if (name != names.value) { // should contain only one element, named "value"
             log.error(pos, "invalid.repeatable.annotation", annoDecl);
             return null;
         }
         if (!(p.snd instanceof Attribute.Class)) { // check that the value of "value" is an Attribute.Class
             log.error(pos, "invalid.repeatable.annotation", annoDecl);
             return null;
         }
         return ((Attribute.Class)p.snd).getValue();
     }
     /* Validate that the suggested targetContainerType Type is a valid
      * container type for repeated instances of originalAnnoType
      * annotations. Return null and report errors if this is not the
      * case, return the MethodSymbol of the value element in
      * targetContainerType if it is suitable (this is needed to
      * synthesize the container). */
     private MethodSymbol validateContainer(Type targetContainerType,
                                            Type originalAnnoType,
                                            DiagnosticPosition pos) {
         MethodSymbol containerValueSymbol = null;
         boolean fatalError = false;
         // Validate that there is a (and only 1) value method
         Scope scope = targetContainerType.tsym.members();
         int nr_value_elems = 0;
         boolean error = false;
         for(Symbol elm : scope.getElementsByName(names.value)) {
             nr_value_elems++;
             if (nr_value_elems == 1 &&
                 elm.kind == Kinds.MTH) {
                 containerValueSymbol = (MethodSymbol)elm;
             } else {
                 error = true;
             }
         }
         if (error) {
             log.error(pos,
                       "invalid.repeatable.annotation.multiple.values",
                       targetContainerType,
                       nr_value_elems);
             return null;
         } else if (nr_value_elems == 0) {
             log.error(pos,
                       "invalid.repeatable.annotation.no.value",
                       targetContainerType);
             return null;
         }
         // validate that the 'value' element is a method
         // probably "impossible" to fail this
         if (containerValueSymbol.kind != Kinds.MTH) {
             log.error(pos,
                       "invalid.repeatable.annotation.invalid.value",
                       targetContainerType);
             fatalError = true;
         }
         // validate that the 'value' element has the correct return type
         // i.e. array of original anno
         Type valueRetType = containerValueSymbol.type.getReturnType();
         Type expectedType = types.makeArrayType(originalAnnoType);
         if (!(types.isArray(valueRetType) &&
               types.isSameType(expectedType, valueRetType))) {
             log.error(pos,
                       "invalid.repeatable.annotation.value.return",
                       targetContainerType,
                       valueRetType,
                       expectedType);
             fatalError = true;
         }
         if (error) {
             fatalError = true;
         }
         // The conditions for a valid containing annotation are made
         // in Check.validateRepeatedAnnotaton();
         return fatalError ? null : containerValueSymbol;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/comp/Annotate.java@f3ca12d680f3 (annotated)

src/share/classes/com/sun/tools/javac/comp/Annotate.java