1 /*
   2  * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.comp;
  27 
  28 import com.sun.tools.javac.code.*;
  29 import com.sun.tools.javac.code.Attribute.Compound;
  30 import com.sun.tools.javac.code.Attribute.TypeCompound;
  31 import com.sun.tools.javac.code.Kinds.KindSelector;
  32 import com.sun.tools.javac.code.Scope.WriteableScope;
  33 import com.sun.tools.javac.code.Source.Feature;
  34 import com.sun.tools.javac.code.Symbol.*;
  35 import com.sun.tools.javac.code.TypeMetadata.Annotations;
  36 import com.sun.tools.javac.comp.Check.CheckContext;
  37 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  38 import com.sun.tools.javac.resources.CompilerProperties.Fragments;
  39 import com.sun.tools.javac.tree.JCTree;
  40 import com.sun.tools.javac.tree.JCTree.*;
  41 import com.sun.tools.javac.tree.TreeInfo;
  42 import com.sun.tools.javac.tree.TreeMaker;
  43 import com.sun.tools.javac.tree.TreeScanner;
  44 import com.sun.tools.javac.util.*;
  45 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
  46 import com.sun.tools.javac.util.List;
  47 
  48 import javax.tools.JavaFileObject;
  49 
  50 import java.util.*;
  51 
  52 import static com.sun.tools.javac.code.Flags.SYNTHETIC;
  53 import static com.sun.tools.javac.code.Kinds.Kind.MDL;
  54 import static com.sun.tools.javac.code.Kinds.Kind.MTH;
  55 import static com.sun.tools.javac.code.Kinds.Kind.PCK;
  56 import static com.sun.tools.javac.code.Kinds.Kind.TYP;
  57 import static com.sun.tools.javac.code.Kinds.Kind.VAR;
  58 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
  59 import static com.sun.tools.javac.code.TypeTag.ARRAY;
  60 import static com.sun.tools.javac.code.TypeTag.CLASS;
  61 import static com.sun.tools.javac.tree.JCTree.Tag.ANNOTATION;
  62 import static com.sun.tools.javac.tree.JCTree.Tag.ASSIGN;
  63 import static com.sun.tools.javac.tree.JCTree.Tag.IDENT;
  64 import static com.sun.tools.javac.tree.JCTree.Tag.NEWARRAY;
  65 
  66 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
  67 
  68 
  69 /** Enter annotations onto symbols and types (and trees).
  70  *
  71  *  This is also a pseudo stage in the compiler taking care of scheduling when annotations are
  72  *  entered.
  73  *
  74  *  <p><b>This is NOT part of any supported API.
  75  *  If you write code that depends on this, you do so at your own risk.
  76  *  This code and its internal interfaces are subject to change or
  77  *  deletion without notice.</b>
  78  */
  79 public class Annotate {
  80     protected static final Context.Key<Annotate> annotateKey = new Context.Key<>();
  81 
  82     public static Annotate instance(Context context) {
  83         Annotate instance = context.get(annotateKey);
  84         if (instance == null)
  85             instance = new Annotate(context);
  86         return instance;
  87     }
  88 
  89     private final Attr attr;
  90     private final Check chk;
  91     private final ConstFold cfolder;
  92     private final DeferredLintHandler deferredLintHandler;
  93     private final Enter enter;
  94     private final Lint lint;
  95     private final Log log;
  96     private final Names names;
  97     private final Resolve resolve;
  98     private final TreeMaker make;
  99     private final Symtab syms;
 100     private final TypeEnvs typeEnvs;
 101     private final Types types;
 102 
 103     private final Attribute theUnfinishedDefaultValue;
 104     private final String sourceName;
 105 
 106     @SuppressWarnings("this-escape")
 107     protected Annotate(Context context) {
 108         context.put(annotateKey, this);
 109 
 110         attr = Attr.instance(context);
 111         chk = Check.instance(context);
 112         cfolder = ConstFold.instance(context);
 113         deferredLintHandler = DeferredLintHandler.instance(context);
 114         enter = Enter.instance(context);
 115         log = Log.instance(context);
 116         lint = Lint.instance(context);
 117         make = TreeMaker.instance(context);
 118         names = Names.instance(context);
 119         resolve = Resolve.instance(context);
 120         syms = Symtab.instance(context);
 121         typeEnvs = TypeEnvs.instance(context);
 122         types = Types.instance(context);
 123 
 124         theUnfinishedDefaultValue =  new Attribute.Error(syms.errType);
 125 
 126         Source source = Source.instance(context);
 127         sourceName = source.name;
 128 
 129         blockCount = 1;
 130     }
 131 
 132     /** Semaphore to delay annotation processing */
 133     private int blockCount = 0;
 134 
 135     /** Called when annotations processing needs to be postponed. */
 136     public void blockAnnotations() {
 137         blockCount++;
 138     }
 139 
 140     /** Called when annotation processing can be resumed. */
 141     public void unblockAnnotations() {
 142         blockCount--;
 143         if (blockCount == 0)
 144             flush();
 145     }
 146 
 147     /** Variant which allows for a delayed flush of annotations.
 148      * Needed by ClassReader */
 149     public void unblockAnnotationsNoFlush() {
 150         blockCount--;
 151     }
 152 
 153     /** are we blocking annotation processing? */
 154     public boolean annotationsBlocked() {return blockCount > 0; }
 155 
 156     public void enterDone() {
 157         unblockAnnotations();
 158     }
 159 
 160     public List<TypeCompound> fromAnnotations(List<JCAnnotation> annotations) {
 161         if (annotations.isEmpty()) {
 162             return List.nil();
 163         }
 164 
 165         ListBuffer<TypeCompound> buf = new ListBuffer<>();
 166         for (JCAnnotation anno : annotations) {
 167             Assert.checkNonNull(anno.attribute);
 168             buf.append((TypeCompound) anno.attribute);
 169         }
 170         return buf.toList();
 171     }
 172 
 173     /** Annotate (used for everything else) */
 174     public void normal(Runnable r) {
 175         q.append(r);
 176     }
 177 
 178     /** Validate, triggers after 'normal' */
 179     public void validate(Runnable a) {
 180         validateQ.append(a);
 181     }
 182 
 183     /** Flush all annotation queues */
 184     public void flush() {
 185         if (annotationsBlocked()) return;
 186         if (isFlushing()) return;
 187 
 188         startFlushing();
 189         try {
 190             while (q.nonEmpty()) {
 191                 q.next().run();
 192             }
 193             while (typesQ.nonEmpty()) {
 194                 typesQ.next().run();
 195             }
 196             while (afterTypesQ.nonEmpty()) {
 197                 afterTypesQ.next().run();
 198             }
 199             while (validateQ.nonEmpty()) {
 200                 validateQ.next().run();
 201             }
 202         } finally {
 203             doneFlushing();
 204         }
 205     }
 206 
 207     private ListBuffer<Runnable> q = new ListBuffer<>();
 208     private ListBuffer<Runnable> validateQ = new ListBuffer<>();
 209 
 210     private int flushCount = 0;
 211     private boolean isFlushing() { return flushCount > 0; }
 212     private void startFlushing() { flushCount++; }
 213     private void doneFlushing() { flushCount--; }
 214 
 215     ListBuffer<Runnable> typesQ = new ListBuffer<>();
 216     ListBuffer<Runnable> afterTypesQ = new ListBuffer<>();
 217 
 218 
 219     public void typeAnnotation(Runnable a) {
 220         typesQ.append(a);
 221     }
 222 
 223     public void afterTypes(Runnable a) {
 224         afterTypesQ.append(a);
 225     }
 226 
 227     /**
 228      * Queue annotations for later attribution and entering. This is probably the method you are looking for.
 229      *
 230      * @param annotations the list of JCAnnotations to attribute and enter
 231      * @param localEnv    the enclosing env
 232      * @param s           the Symbol on which to enter the annotations
 233      * @param deferPos    report errors here
 234      */
 235     public void annotateLater(List<JCAnnotation> annotations, Env<AttrContext> localEnv,
 236             Symbol s, DiagnosticPosition deferPos)
 237     {
 238         if (annotations.isEmpty()) {
 239             return;
 240         }
 241 
 242         s.resetAnnotations(); // mark Annotations as incomplete for now
 243 
 244         normal(() -> {
 245             // Packages are unusual, in that they are the only type of declaration that can legally appear
 246             // more than once in a compilation, and in all cases refer to the same underlying symbol.
 247             // This means they are the only kind of declaration that syntactically may have multiple sets
 248             // of annotations, each on a different package declaration, even though that is ultimately
 249             // forbidden by JLS 8 section 7.4.
 250             // The corollary here is that all of the annotations on a package symbol may have already
 251             // been handled, meaning that the set of annotations pending completion is now empty.
 252             Assert.check(s.kind == PCK || s.annotationsPendingCompletion());
 253             JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
 254             DiagnosticPosition prevLintPos =
 255                     deferPos != null
 256                             ? deferredLintHandler.setPos(deferPos)
 257                             : deferredLintHandler.immediate();
 258             Lint prevLint = deferPos != null ? null : chk.setLint(lint);
 259             try {
 260                 if (s.hasAnnotations() && annotations.nonEmpty())
 261                     log.error(annotations.head.pos, Errors.AlreadyAnnotated(Kinds.kindName(s), s));
 262 
 263                 Assert.checkNonNull(s, "Symbol argument to actualEnterAnnotations is null");
 264 
 265                 // false is passed as fifth parameter since annotateLater is
 266                 // never called for a type parameter
 267                 annotateNow(s, annotations, localEnv, false, false);
 268             } finally {
 269                 if (prevLint != null)
 270                     chk.setLint(prevLint);
 271                 deferredLintHandler.setPos(prevLintPos);
 272                 log.useSource(prev);
 273             }
 274         });
 275 
 276         validate(() -> { //validate annotations
 277             JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
 278             try {
 279                 chk.validateAnnotations(annotations, TreeInfo.declarationFor(s, localEnv.tree), s);
 280             } finally {
 281                 log.useSource(prev);
 282             }
 283         });
 284     }
 285 
 286 
 287     /** Queue processing of an attribute default value. */
 288     public void annotateDefaultValueLater(JCExpression defaultValue, Env<AttrContext> localEnv,
 289             MethodSymbol m, DiagnosticPosition deferPos)
 290     {
 291         normal(() -> {
 292             JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
 293             DiagnosticPosition prevLintPos = deferredLintHandler.setPos(deferPos);
 294             try {
 295                 enterDefaultValue(defaultValue, localEnv, m);
 296             } finally {
 297                 deferredLintHandler.setPos(prevLintPos);
 298                 log.useSource(prev);
 299             }
 300         });
 301 
 302         validate(() -> { //validate annotations
 303             JavaFileObject prev = log.useSource(localEnv.toplevel.sourcefile);
 304             try {
 305                 // if default value is an annotation, check it is a well-formed
 306                 // annotation value (e.g. no duplicate values, no missing values, etc.)
 307                 chk.validateAnnotationTree(defaultValue);
 308             } finally {
 309                 log.useSource(prev);
 310             }
 311         });
 312     }
 313 
 314     /** Enter a default value for an annotation element. */
 315     private void enterDefaultValue(JCExpression defaultValue,
 316             Env<AttrContext> localEnv, MethodSymbol m) {
 317         m.defaultValue = attributeAnnotationValue(m.type.getReturnType(), defaultValue, localEnv);
 318     }
 319 
 320     /**
 321      * Gather up annotations into a map from type symbols to lists of Compound attributes,
 322      * then continue on with repeating annotations processing.
 323      */
 324     private <T extends Attribute.Compound> void annotateNow(Symbol toAnnotate,
 325             List<JCAnnotation> withAnnotations, Env<AttrContext> env, boolean typeAnnotations,
 326             boolean isTypeParam)
 327     {
 328         Map<TypeSymbol, ListBuffer<T>> annotated = new LinkedHashMap<>();
 329         Map<T, DiagnosticPosition> pos = new HashMap<>();
 330 
 331         for (List<JCAnnotation> al = withAnnotations; !al.isEmpty(); al = al.tail) {
 332             JCAnnotation a = al.head;
 333 
 334             T c;
 335             if (typeAnnotations) {
 336                 @SuppressWarnings("unchecked")
 337                 T tmp = (T)attributeTypeAnnotation(a, syms.annotationType, env);
 338                 c = tmp;
 339             } else {
 340                 @SuppressWarnings("unchecked")
 341                 T tmp = (T)attributeAnnotation(a, syms.annotationType, env);
 342                 c = tmp;
 343             }
 344 
 345             Assert.checkNonNull(c, "Failed to create annotation");
 346 
 347             if (a.type.isErroneous() || a.type.tsym.isAnnotationType()) {
 348                 if (annotated.containsKey(a.type.tsym)) {
 349                     ListBuffer<T> l = annotated.get(a.type.tsym);
 350                     l = l.append(c);
 351                     annotated.put(a.type.tsym, l);
 352                     pos.put(c, a.pos());
 353                 } else {
 354                     annotated.put(a.type.tsym, ListBuffer.of(c));
 355                     pos.put(c, a.pos());
 356                 }
 357             }
 358 
 359             // Note: @Deprecated has no effect on local variables and parameters
 360             if (!c.type.isErroneous()
 361                     && (toAnnotate.kind == MDL || toAnnotate.owner.kind != MTH)
 362                     && types.isSameType(c.type, syms.deprecatedType)) {
 363                 toAnnotate.flags_field |= (Flags.DEPRECATED | Flags.DEPRECATED_ANNOTATION);
 364                 if (isAttributeTrue(c.member(names.forRemoval))) {
 365                     toAnnotate.flags_field |= Flags.DEPRECATED_REMOVAL;
 366                 }
 367             }
 368 
 369             if (!c.type.isErroneous()
 370                     && types.isSameType(c.type, syms.previewFeatureType)) {
 371                 toAnnotate.flags_field |= Flags.PREVIEW_API;
 372                 if (isAttributeTrue(c.member(names.reflective))) {
 373                     toAnnotate.flags_field |= Flags.PREVIEW_REFLECTIVE;
 374                 }
 375             }
 376 
 377             if (!c.type.isErroneous()
 378                     && toAnnotate.kind == TYP
 379                     && types.isSameType(c.type, syms.valueBasedType)) {
 380                 toAnnotate.flags_field |= Flags.VALUE_BASED;
 381             }
 382 
 383             if (!c.type.isErroneous()
 384                     && types.isSameType(c.type, syms.restrictedType)) {
 385                 toAnnotate.flags_field |= Flags.RESTRICTED;
 386             }
 387         }
 388 
 389         List<T> buf = List.nil();
 390         for (ListBuffer<T> lb : annotated.values()) {
 391             if (lb.size() == 1) {
 392                 buf = buf.prepend(lb.first());
 393             } else {
 394                 AnnotationContext<T> ctx = new AnnotationContext<>(env, annotated, pos, typeAnnotations);
 395                 T res = makeContainerAnnotation(lb.toList(), ctx, toAnnotate, isTypeParam);
 396                 if (res != null)
 397                     buf = buf.prepend(res);
 398             }
 399         }
 400 
 401         if (typeAnnotations) {
 402             @SuppressWarnings("unchecked")
 403             List<TypeCompound> attrs = (List<TypeCompound>)buf.reverse();
 404             toAnnotate.appendUniqueTypeAttributes(attrs);
 405         } else {
 406             @SuppressWarnings("unchecked")
 407             List<Attribute.Compound> attrs =  (List<Attribute.Compound>)buf.reverse();
 408             toAnnotate.resetAnnotations();
 409             toAnnotate.setDeclarationAttributes(attrs);
 410         }
 411     }
 412     //where:
 413         private boolean isAttributeTrue(Attribute attr) {
 414             return (attr instanceof Attribute.Constant constant)
 415                     && constant.type == syms.booleanType
 416                     && ((Integer) constant.value) != 0;
 417         }
 418 
 419     /**
 420      * Attribute and store a semantic representation of the annotation tree {@code tree} into the
 421      * tree.attribute field.
 422      *
 423      * @param tree the tree representing an annotation
 424      * @param expectedAnnotationType the expected (super)type of the annotation
 425      * @param env the current env in where the annotation instance is found
 426      */
 427     public Attribute.Compound attributeAnnotation(JCAnnotation tree, Type expectedAnnotationType,
 428                                                   Env<AttrContext> env)
 429     {
 430         // The attribute might have been entered if it is Target or Repeatable
 431         // Because TreeCopier does not copy type, redo this if type is null
 432         if (tree.attribute != null && tree.type != null)
 433             return tree.attribute;
 434 
 435         List<Pair<MethodSymbol, Attribute>> elems = attributeAnnotationValues(tree, expectedAnnotationType, env);
 436         Attribute.Compound ac = new Attribute.Compound(tree.type, elems);
 437 
 438         return tree.attribute = ac;
 439     }
 440 
 441     /** Attribute and store a semantic representation of the type annotation tree {@code tree} into
 442      * the tree.attribute field.
 443      *
 444      * @param a the tree representing an annotation
 445      * @param expectedAnnotationType the expected (super)type of the annotation
 446      * @param env the current env in where the annotation instance is found
 447      */
 448     public Attribute.TypeCompound attributeTypeAnnotation(JCAnnotation a, Type expectedAnnotationType,
 449                                                           Env<AttrContext> env)
 450     {
 451         // The attribute might have been entered if it is Target or Repeatable
 452         // Because TreeCopier does not copy type, redo this if type is null
 453         if (a.attribute == null || a.type == null || !(a.attribute instanceof Attribute.TypeCompound typeCompound)) {
 454             // Create a new TypeCompound
 455             List<Pair<MethodSymbol,Attribute>> elems =
 456                     attributeAnnotationValues(a, expectedAnnotationType, env);
 457 
 458             Attribute.TypeCompound tc =
 459                     new Attribute.TypeCompound(a.type, elems, TypeAnnotationPosition.unknown);
 460             a.attribute = tc;
 461             return tc;
 462         } else {
 463             // Use an existing TypeCompound
 464             return typeCompound;
 465         }
 466     }
 467 
 468     /**
 469      *  Attribute annotation elements creating a list of pairs of the Symbol representing that
 470      *  element and the value of that element as an Attribute. */
 471     private List<Pair<MethodSymbol, Attribute>> attributeAnnotationValues(JCAnnotation a,
 472             Type expected, Env<AttrContext> env)
 473     {
 474         // The annotation might have had its type attributed (but not
 475         // checked) by attr.attribAnnotationTypes during MemberEnter,
 476         // in which case we do not need to do it again.
 477         Type at = (a.annotationType.type != null ?
 478                 a.annotationType.type : attr.attribType(a.annotationType, env));
 479         a.type = chk.checkType(a.annotationType.pos(), at, expected);
 480 
 481         boolean isError = a.type.isErroneous();
 482         if (!a.type.tsym.isAnnotationType() && !isError) {
 483             log.error(a.annotationType.pos(), Errors.NotAnnotationType(a.type));
 484             isError = true;
 485         }
 486 
 487         // List of name=value pairs (or implicit "value=" if size 1)
 488         List<JCExpression> args = a.args;
 489 
 490         boolean elidedValue = false;
 491         // special case: elided "value=" assumed
 492         if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {
 493             args.head = make.at(args.head.pos).
 494                     Assign(make.Ident(names.value), args.head);
 495             elidedValue = true;
 496         }
 497 
 498         ListBuffer<Pair<MethodSymbol,Attribute>> buf = new ListBuffer<>();
 499         for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {
 500             Pair<MethodSymbol, Attribute> p = attributeAnnotationNameValuePair(tl.head, a.type, isError, env, elidedValue);
 501             if (p != null && !p.fst.type.isErroneous())
 502                 buf.append(p);
 503         }
 504         return buf.toList();
 505     }
 506 
 507     // where
 508     private Pair<MethodSymbol, Attribute> attributeAnnotationNameValuePair(JCExpression nameValuePair,
 509             Type thisAnnotationType, boolean badAnnotation, Env<AttrContext> env, boolean elidedValue)
 510     {
 511         if (!nameValuePair.hasTag(ASSIGN)) {
 512             log.error(nameValuePair.pos(), Errors.AnnotationValueMustBeNameValue);
 513             attributeAnnotationValue(nameValuePair.type = syms.errType, nameValuePair, env);
 514             return null;
 515         }
 516         JCAssign assign = (JCAssign)nameValuePair;
 517         if (!assign.lhs.hasTag(IDENT)) {
 518             log.error(nameValuePair.pos(), Errors.AnnotationValueMustBeNameValue);
 519             attributeAnnotationValue(nameValuePair.type = syms.errType, nameValuePair, env);
 520             return null;
 521         }
 522 
 523         // Resolve element to MethodSym
 524         JCIdent left = (JCIdent)assign.lhs;
 525         Symbol method = resolve.resolveQualifiedMethod(elidedValue ? assign.rhs.pos() : left.pos(),
 526                 env, thisAnnotationType,
 527                 left.name, List.nil(), null);
 528         left.sym = method;
 529         left.type = method.type;
 530         chk.checkDeprecated(left, env.info.scope.owner, method);
 531         if (method.owner != thisAnnotationType.tsym && !badAnnotation)
 532             log.error(left.pos(), Errors.NoAnnotationMember(left.name, thisAnnotationType));
 533         Type resultType = method.type.getReturnType();
 534 
 535         // Compute value part
 536         Attribute value = attributeAnnotationValue(resultType, assign.rhs, env);
 537         nameValuePair.type = resultType;
 538 
 539         return method.type.isErroneous() ? null : new Pair<>((MethodSymbol)method, value);
 540 
 541     }
 542 
 543     /** Attribute an annotation element value */
 544     private Attribute attributeAnnotationValue(Type expectedElementType, JCExpression tree,
 545             Env<AttrContext> env)
 546     {
 547         //first, try completing the symbol for the annotation value - if a completion
 548         //error is thrown, we should recover gracefully, and display an
 549         //ordinary resolution diagnostic.
 550         try {
 551             expectedElementType.tsym.complete();
 552         } catch(CompletionFailure e) {
 553             log.error(tree.pos(), Errors.CantResolve(Kinds.kindName(e.sym), e.sym.getQualifiedName(), null, null));
 554             expectedElementType = syms.errType;
 555         }
 556 
 557         if (expectedElementType.hasTag(ARRAY)) {
 558             return getAnnotationArrayValue(expectedElementType, tree, env);
 559         }
 560 
 561         //error recovery
 562         if (tree.hasTag(NEWARRAY)) {
 563             if (!expectedElementType.isErroneous())
 564                 log.error(tree.pos(), Errors.AnnotationValueNotAllowableType);
 565             JCNewArray na = (JCNewArray)tree;
 566             if (na.elemtype != null) {
 567                 log.error(na.elemtype.pos(), Errors.NewNotAllowedInAnnotation);
 568             }
 569             for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
 570                 attributeAnnotationValue(syms.errType,
 571                         l.head,
 572                         env);
 573             }
 574             return new Attribute.Error(syms.errType);
 575         }
 576 
 577         if (expectedElementType.tsym.isAnnotationType()) {
 578             if (tree.hasTag(ANNOTATION)) {
 579                 return attributeAnnotation((JCAnnotation)tree, expectedElementType, env);
 580             } else {
 581                 log.error(tree.pos(), Errors.AnnotationValueMustBeAnnotation);
 582                 expectedElementType = syms.errType;
 583             }
 584         }
 585 
 586         //error recovery
 587         if (tree.hasTag(ANNOTATION)) {
 588             if (!expectedElementType.isErroneous())
 589                 log.error(tree.pos(), Errors.AnnotationNotValidForType(expectedElementType));
 590             attributeAnnotation((JCAnnotation)tree, syms.errType, env);
 591             return new Attribute.Error(((JCAnnotation)tree).annotationType.type);
 592         }
 593 
 594         MemberEnter.InitTreeVisitor initTreeVisitor = new MemberEnter.InitTreeVisitor() {
 595             // the methods below are added to allow class literals on top of constant expressions
 596             @Override
 597             public void visitTypeIdent(JCPrimitiveTypeTree that) {}
 598 
 599             @Override
 600             public void visitTypeArray(JCArrayTypeTree that) {}
 601         };
 602         tree.accept(initTreeVisitor);
 603         if (!initTreeVisitor.result) {
 604             log.error(tree.pos(), Errors.ExpressionNotAllowableAsAnnotationValue);
 605             return new Attribute.Error(syms.errType);
 606         }
 607 
 608         if (expectedElementType.isPrimitive() ||
 609                 (types.isSameType(expectedElementType, syms.stringType) && !expectedElementType.hasTag(TypeTag.ERROR))) {
 610             return getAnnotationPrimitiveValue(expectedElementType, tree, env);
 611         }
 612 
 613         if (expectedElementType.tsym == syms.classType.tsym) {
 614             return getAnnotationClassValue(expectedElementType, tree, env);
 615         }
 616 
 617         if (expectedElementType.hasTag(CLASS) &&
 618                 (expectedElementType.tsym.flags() & Flags.ENUM) != 0) {
 619             return getAnnotationEnumValue(expectedElementType, tree, env);
 620         }
 621 
 622         //error recovery:
 623         if (!expectedElementType.isErroneous())
 624             log.error(tree.pos(), Errors.AnnotationValueNotAllowableType);
 625         return new Attribute.Error(attr.attribExpr(tree, env, expectedElementType));
 626     }
 627 
 628     private Attribute getAnnotationEnumValue(Type expectedElementType, JCExpression tree, Env<AttrContext> env) {
 629         Type result = attr.attribTree(tree, env, annotationValueInfo(expectedElementType));
 630         Symbol sym = TreeInfo.symbol(tree);
 631         if (sym == null ||
 632                 TreeInfo.nonstaticSelect(tree) ||
 633                 sym.kind != VAR ||
 634                 (sym.flags() & Flags.ENUM) == 0) {
 635             log.error(tree.pos(), Errors.EnumAnnotationMustBeEnumConstant);
 636             return new Attribute.Error(result.getOriginalType());
 637         }
 638         VarSymbol enumerator = (VarSymbol) sym;
 639         return new Attribute.Enum(expectedElementType, enumerator);
 640     }
 641 
 642     private Attribute getAnnotationClassValue(Type expectedElementType, JCExpression tree, Env<AttrContext> env) {
 643         Type result = attr.attribTree(tree, env, annotationValueInfo(expectedElementType));
 644         if (result.isErroneous()) {
 645             // Does it look like an unresolved class literal?
 646             if (TreeInfo.name(tree) == names._class &&
 647                     ((JCFieldAccess) tree).selected.type.isErroneous()) {
 648                 Name n = (((JCFieldAccess) tree).selected).type.tsym.flatName();
 649                 return new Attribute.UnresolvedClass(expectedElementType,
 650                         types.createErrorType(n,
 651                                 syms.unknownSymbol, syms.classType));
 652             } else {
 653                 return new Attribute.Error(result.getOriginalType());
 654             }
 655         }
 656 
 657         // Class literals look like field accesses of a field named class
 658         // at the tree level
 659         if (TreeInfo.name(tree) != names._class) {
 660             log.error(tree.pos(), Errors.AnnotationValueMustBeClassLiteral);
 661             return new Attribute.Error(syms.errType);
 662         }
 663 
 664         return new Attribute.Class(types,
 665                 (((JCFieldAccess) tree).selected).type);
 666     }
 667 
 668     private Attribute getAnnotationPrimitiveValue(Type expectedElementType, JCExpression tree, Env<AttrContext> env) {
 669         Type result = attr.attribTree(tree, env, annotationValueInfo(expectedElementType));
 670         if (result.isErroneous())
 671             return new Attribute.Error(result.getOriginalType());
 672         if (result.constValue() == null) {
 673             log.error(tree.pos(), Errors.AttributeValueMustBeConstant);
 674             return new Attribute.Error(expectedElementType);
 675         }
 676 
 677         // Scan the annotation element value and then attribute nested annotations if present
 678         if (tree.type != null && tree.type.tsym != null) {
 679             queueScanTreeAndTypeAnnotate(tree, env, tree.type.tsym, tree.pos());
 680         }
 681 
 682         result = cfolder.coerce(result, expectedElementType);
 683         return new Attribute.Constant(expectedElementType, result.constValue());
 684     }
 685 
 686     private Attr.ResultInfo annotationValueInfo(Type pt) {
 687         return attr.unknownExprInfo.dup(pt, new AnnotationValueContext(attr.unknownExprInfo.checkContext));
 688     }
 689 
 690     class AnnotationValueContext extends Check.NestedCheckContext {
 691         AnnotationValueContext(CheckContext enclosingContext) {
 692             super(enclosingContext);
 693         }
 694 
 695         @Override
 696         public boolean compatible(Type found, Type req, Warner warn) {
 697             //handle non-final implicitly-typed vars (will be rejected later on)
 698             return found.hasTag(TypeTag.NONE) || super.compatible(found, req, warn);
 699         }
 700     }
 701 
 702     private Attribute getAnnotationArrayValue(Type expectedElementType, JCExpression tree, Env<AttrContext> env) {
 703         // Special case, implicit array
 704         if (!tree.hasTag(NEWARRAY)) {
 705             tree = make.at(tree.pos).
 706                     NewArray(null, List.nil(), List.of(tree));
 707         }
 708 
 709         JCNewArray na = (JCNewArray)tree;
 710         if (na.elemtype != null) {
 711             log.error(na.elemtype.pos(), Errors.NewNotAllowedInAnnotation);
 712         }
 713         ListBuffer<Attribute> buf = new ListBuffer<>();
 714         for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
 715             buf.append(attributeAnnotationValue(types.elemtype(expectedElementType),
 716                     l.head,
 717                     env));
 718         }
 719         na.type = expectedElementType;
 720         return new Attribute.
 721                 Array(expectedElementType, buf.toArray(new Attribute[buf.length()]));
 722     }
 723 
 724     /* *********************************
 725      * Support for repeating annotations
 726      ***********************************/
 727 
 728     /**
 729      * This context contains all the information needed to synthesize new
 730      * annotations trees for repeating annotations.
 731      */
 732     private class AnnotationContext<T extends Attribute.Compound> {
 733         public final Env<AttrContext> env;
 734         public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;
 735         public final Map<T, JCDiagnostic.DiagnosticPosition> pos;
 736         public final boolean isTypeCompound;
 737 
 738         public AnnotationContext(Env<AttrContext> env,
 739                                  Map<Symbol.TypeSymbol, ListBuffer<T>> annotated,
 740                                  Map<T, JCDiagnostic.DiagnosticPosition> pos,
 741                                  boolean isTypeCompound) {
 742             Assert.checkNonNull(env);
 743             Assert.checkNonNull(annotated);
 744             Assert.checkNonNull(pos);
 745 
 746             this.env = env;
 747             this.annotated = annotated;
 748             this.pos = pos;
 749             this.isTypeCompound = isTypeCompound;
 750         }
 751     }
 752 
 753     /* Process repeated annotations. This method returns the
 754      * synthesized container annotation or null IFF all repeating
 755      * annotation are invalid.  This method reports errors/warnings.
 756      */
 757     private <T extends Attribute.Compound> T processRepeatedAnnotations(List<T> annotations,
 758             AnnotationContext<T> ctx, Symbol on, boolean isTypeParam)
 759     {
 760         T firstOccurrence = annotations.head;
 761         List<Attribute> repeated = List.nil();
 762         Type origAnnoType = null;
 763         Type arrayOfOrigAnnoType = null;
 764         Type targetContainerType = null;
 765         MethodSymbol containerValueSymbol = null;
 766 
 767         Assert.check(!annotations.isEmpty() && !annotations.tail.isEmpty()); // i.e. size() > 1
 768 
 769         int count = 0;
 770         for (List<T> al = annotations; !al.isEmpty(); al = al.tail) {
 771             count++;
 772 
 773             // There must be more than a single anno in the annotation list
 774             Assert.check(count > 1 || !al.tail.isEmpty());
 775 
 776             T currentAnno = al.head;
 777 
 778             origAnnoType = currentAnno.type;
 779             if (arrayOfOrigAnnoType == null) {
 780                 arrayOfOrigAnnoType = types.makeArrayType(origAnnoType);
 781             }
 782 
 783             // Only report errors if this isn't the first occurrence I.E. count > 1
 784             boolean reportError = count > 1;
 785             Type currentContainerType = getContainingType(currentAnno, ctx.pos.get(currentAnno), reportError);
 786             if (currentContainerType == null) {
 787                 continue;
 788             }
 789             // Assert that the target Container is == for all repeated
 790             // annos of the same annotation type, the types should
 791             // come from the same Symbol, i.e. be '=='
 792             Assert.check(targetContainerType == null || currentContainerType == targetContainerType);
 793             targetContainerType = currentContainerType;
 794 
 795             containerValueSymbol = validateContainer(targetContainerType, origAnnoType, ctx.pos.get(currentAnno));
 796 
 797             if (containerValueSymbol == null) { // Check of CA type failed
 798                 // errors are already reported
 799                 continue;
 800             }
 801 
 802             repeated = repeated.prepend(currentAnno);
 803         }
 804 
 805         if (!repeated.isEmpty() && targetContainerType == null) {
 806             log.error(ctx.pos.get(annotations.head), Errors.DuplicateAnnotationInvalidRepeated(origAnnoType));
 807             return null;
 808         }
 809 
 810         if (!repeated.isEmpty()) {
 811             repeated = repeated.reverse();
 812             DiagnosticPosition pos = ctx.pos.get(firstOccurrence);
 813             TreeMaker m = make.at(pos);
 814             Pair<MethodSymbol, Attribute> p =
 815                     new Pair<MethodSymbol, Attribute>(containerValueSymbol,
 816                             new Attribute.Array(arrayOfOrigAnnoType, repeated));
 817             if (ctx.isTypeCompound) {
 818                 /* TODO: the following code would be cleaner:
 819                 Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
 820                         ((Attribute.TypeCompound)annotations.head).position);
 821                 JCTypeAnnotation annoTree = m.TypeAnnotation(at);
 822                 at = attributeTypeAnnotation(annoTree, targetContainerType, ctx.env);
 823                 */
 824                 // However, we directly construct the TypeCompound to keep the
 825                 // direct relation to the contained TypeCompounds.
 826                 Attribute.TypeCompound at = new Attribute.TypeCompound(targetContainerType, List.of(p),
 827                         ((Attribute.TypeCompound)annotations.head).position);
 828 
 829                 JCAnnotation annoTree = m.TypeAnnotation(at);
 830                 if (!chk.validateAnnotationDeferErrors(annoTree))
 831                     log.error(annoTree.pos(), Errors.DuplicateAnnotationInvalidRepeated(origAnnoType));
 832 
 833                 if (!chk.isTypeAnnotation(annoTree, isTypeParam)) {
 834                     log.error(pos, isTypeParam ? Errors.InvalidRepeatableAnnotationNotApplicable(targetContainerType, on)
 835                                                : Errors.InvalidRepeatableAnnotationNotApplicableInContext(targetContainerType));
 836                 }
 837 
 838                 at.setSynthesized(true);
 839 
 840                 @SuppressWarnings("unchecked")
 841                 T x = (T) at;
 842                 return x;
 843             } else {
 844                 Attribute.Compound c = new Attribute.Compound(targetContainerType, List.of(p));
 845                 JCAnnotation annoTree = m.Annotation(c);
 846 
 847                 boolean isRecordMember = (on.flags_field & Flags.RECORD) != 0 || on.enclClass() != null && on.enclClass().isRecord();
 848                 /* if it is a record member we will not issue the error now and wait until annotations on records are
 849                  * checked at Check::validateAnnotation, which will issue it
 850                  */
 851                 if (!chk.annotationApplicable(annoTree, on) && (!isRecordMember || isRecordMember && (on.flags_field & Flags.GENERATED_MEMBER) == 0)) {
 852                     log.error(annoTree.pos(),
 853                               Errors.InvalidRepeatableAnnotationNotApplicable(targetContainerType, on));
 854                 }
 855 
 856                 if (!chk.validateAnnotationDeferErrors(annoTree))
 857                     log.error(annoTree.pos(), Errors.DuplicateAnnotationInvalidRepeated(origAnnoType));
 858 
 859                 c = attributeAnnotation(annoTree, targetContainerType, ctx.env);
 860                 c.setSynthesized(true);
 861 
 862                 @SuppressWarnings("unchecked")
 863                 T x = (T) c;
 864                 return x;
 865             }
 866         } else {
 867             return null; // errors should have been reported elsewhere
 868         }
 869     }
 870 
 871     /**
 872      * Fetches the actual Type that should be the containing annotation.
 873      */
 874     private Type getContainingType(Attribute.Compound currentAnno,
 875                                    DiagnosticPosition pos,
 876                                    boolean reportError)
 877     {
 878         Type origAnnoType = currentAnno.type;
 879         TypeSymbol origAnnoDecl = origAnnoType.tsym;
 880 
 881         // Fetch the Repeatable annotation from the current
 882         // annotation's declaration, or null if it has none
 883         Attribute.Compound ca = origAnnoDecl.getAnnotationTypeMetadata().getRepeatable();
 884         if (ca == null) { // has no Repeatable annotation
 885             if (reportError)
 886                 log.error(pos, Errors.DuplicateAnnotationMissingContainer(origAnnoType));
 887             return null;
 888         }
 889 
 890         return filterSame(extractContainingType(ca, pos, origAnnoDecl),
 891                 origAnnoType);
 892     }
 893 
 894     // returns null if t is same as 's', returns 't' otherwise
 895     private Type filterSame(Type t, Type s) {
 896         if (t == null || s == null) {
 897             return t;
 898         }
 899 
 900         return types.isSameType(t, s) ? null : t;
 901     }
 902 
 903     /** Extract the actual Type to be used for a containing annotation. */
 904     private Type extractContainingType(Attribute.Compound ca,
 905                                        DiagnosticPosition pos,
 906                                        TypeSymbol annoDecl)
 907     {
 908         // The next three checks check that the Repeatable annotation
 909         // on the declaration of the annotation type that is repeating is
 910         // valid.
 911 
 912         // Repeatable must have at least one element
 913         if (ca.values.isEmpty()) {
 914             log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl));
 915             return null;
 916         }
 917         Pair<MethodSymbol,Attribute> p = ca.values.head;
 918         Name name = p.fst.name;
 919         if (name != names.value) { // should contain only one element, named "value"
 920             log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl));
 921             return null;
 922         }
 923         if (!(p.snd instanceof Attribute.Class attributeClass)) { // check that the value of "value" is an Attribute.Class
 924             log.error(pos, Errors.InvalidRepeatableAnnotation(annoDecl));
 925             return null;
 926         }
 927 
 928         return attributeClass.getValue();
 929     }
 930 
 931     /* Validate that the suggested targetContainerType Type is a valid
 932      * container type for repeated instances of originalAnnoType
 933      * annotations. Return null and report errors if this is not the
 934      * case, return the MethodSymbol of the value element in
 935      * targetContainerType if it is suitable (this is needed to
 936      * synthesize the container). */
 937     private MethodSymbol validateContainer(Type targetContainerType,
 938                                            Type originalAnnoType,
 939                                            DiagnosticPosition pos) {
 940         MethodSymbol containerValueSymbol = null;
 941         boolean fatalError = false;
 942 
 943         // Validate that there is a (and only 1) value method
 944         Scope scope = targetContainerType.tsym.members();
 945         int nr_value_elems = 0;
 946         boolean error = false;
 947         for(Symbol elm : scope.getSymbolsByName(names.value)) {
 948             nr_value_elems++;
 949 
 950             if (nr_value_elems == 1 &&
 951                     elm.kind == MTH) {
 952                 containerValueSymbol = (MethodSymbol)elm;
 953             } else {
 954                 error = true;
 955             }
 956         }
 957         if (error) {
 958             log.error(pos,
 959                       Errors.InvalidRepeatableAnnotationMultipleValues(targetContainerType,
 960                                                                        nr_value_elems));
 961             return null;
 962         } else if (nr_value_elems == 0) {
 963             log.error(pos,
 964                       Errors.InvalidRepeatableAnnotationNoValue(targetContainerType));
 965             return null;
 966         }
 967 
 968         // validate that the 'value' element is a method
 969         // probably "impossible" to fail this
 970         if (containerValueSymbol.kind != MTH) {
 971             log.error(pos,
 972                     Errors.InvalidRepeatableAnnotationInvalidValue(targetContainerType));
 973             fatalError = true;
 974         }
 975 
 976         // validate that the 'value' element has the correct return type
 977         // i.e. array of original anno
 978         Type valueRetType = containerValueSymbol.type.getReturnType();
 979         Type expectedType = types.makeArrayType(originalAnnoType);
 980         if (!(types.isArray(valueRetType) &&
 981                 types.isSameType(expectedType, valueRetType))) {
 982             log.error(pos,
 983                       Errors.InvalidRepeatableAnnotationValueReturn(targetContainerType,
 984                                                                     valueRetType,
 985                                                                     expectedType));
 986             fatalError = true;
 987         }
 988 
 989         return fatalError ? null : containerValueSymbol;
 990     }
 991 
 992     private <T extends Attribute.Compound> T makeContainerAnnotation(List<T> toBeReplaced,
 993             AnnotationContext<T> ctx, Symbol sym, boolean isTypeParam)
 994     {
 995         // Process repeated annotations
 996         T validRepeated =
 997                 processRepeatedAnnotations(toBeReplaced, ctx, sym, isTypeParam);
 998 
 999         if (validRepeated != null) {
1000             // Check that the container isn't manually
1001             // present along with repeated instances of
1002             // its contained annotation.
1003             ListBuffer<T> manualContainer = ctx.annotated.get(validRepeated.type.tsym);
1004             if (manualContainer != null) {
1005                 log.error(ctx.pos.get(manualContainer.first()),
1006                           Errors.InvalidRepeatableAnnotationRepeatedAndContainerPresent(manualContainer.first().type.tsym));
1007             }
1008         }
1009 
1010         // A null return will delete the Placeholder
1011         return validRepeated;
1012     }
1013 
1014     /********************
1015      * Type annotations *
1016      ********************/
1017 
1018     /**
1019      * Attribute the list of annotations and enter them onto s.
1020      */
1021     public void enterTypeAnnotations(List<JCAnnotation> annotations, Env<AttrContext> env,
1022             Symbol s, DiagnosticPosition deferPos, boolean isTypeParam)
1023     {
1024         Assert.checkNonNull(s, "Symbol argument to actualEnterTypeAnnotations is nul/");
1025         JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
1026         DiagnosticPosition prevLintPos = null;
1027 
1028         if (deferPos != null) {
1029             prevLintPos = deferredLintHandler.setPos(deferPos);
1030         }
1031         try {
1032             annotateNow(s, annotations, env, true, isTypeParam);
1033         } finally {
1034             if (prevLintPos != null)
1035                 deferredLintHandler.setPos(prevLintPos);
1036             log.useSource(prev);
1037         }
1038     }
1039 
1040     /**
1041      * Enqueue tree for scanning of type annotations, attaching to the Symbol sym.
1042      */
1043     public void queueScanTreeAndTypeAnnotate(JCTree tree, Env<AttrContext> env, Symbol sym,
1044             DiagnosticPosition deferPos)
1045     {
1046         Assert.checkNonNull(sym);
1047         normal(() -> tree.accept(new TypeAnnotate(env, sym, deferPos)));
1048     }
1049 
1050     /**
1051      * Apply the annotations to the particular type.
1052      */
1053     public void annotateTypeSecondStage(JCTree tree, List<JCAnnotation> annotations, Type storeAt) {
1054         typeAnnotation(() -> {
1055             List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
1056             Assert.check(annotations.size() == compounds.size());
1057             // the type already has annotation metadata, but it's empty
1058             Annotations metadata = storeAt.getMetadata(Annotations.class);
1059             Assert.checkNonNull(metadata);
1060             Assert.check(metadata.annotationBuffer().isEmpty());
1061             metadata.annotationBuffer().appendList(compounds);
1062         });
1063     }
1064 
1065     /**
1066      * Apply the annotations to the particular type.
1067      */
1068     public void annotateTypeParameterSecondStage(JCTree tree, List<JCAnnotation> annotations) {
1069         typeAnnotation(() -> {
1070             List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
1071             Assert.check(annotations.size() == compounds.size());
1072         });
1073     }
1074 
1075     /**
1076      * We need to use a TreeScanner, because it is not enough to visit the top-level
1077      * annotations. We also need to visit type arguments, etc.
1078      */
1079     private class TypeAnnotate extends TreeScanner {
1080         private final Env<AttrContext> env;
1081         private final Symbol sym;
1082         private DiagnosticPosition deferPos;
1083 
1084         public TypeAnnotate(Env<AttrContext> env, Symbol sym, DiagnosticPosition deferPos) {
1085 
1086             this.env = env;
1087             this.sym = sym;
1088             this.deferPos = deferPos;
1089         }
1090 
1091         @Override
1092         public void visitAnnotatedType(JCAnnotatedType tree) {
1093             enterTypeAnnotations(tree.annotations, env, sym, deferPos, false);
1094             scan(tree.underlyingType);
1095         }
1096 
1097         @Override
1098         public void visitTypeParameter(JCTypeParameter tree) {
1099             enterTypeAnnotations(tree.annotations, env, sym, deferPos, true);
1100             scan(tree.bounds);
1101         }
1102 
1103         @Override
1104         public void visitNewArray(JCNewArray tree) {
1105             enterTypeAnnotations(tree.annotations, env, sym, deferPos, false);
1106             for (List<JCAnnotation> dimAnnos : tree.dimAnnotations)
1107                 enterTypeAnnotations(dimAnnos, env, sym, deferPos, false);
1108             scan(tree.elemtype);
1109             scan(tree.elems);
1110         }
1111 
1112         @Override
1113         public void visitMethodDef(JCMethodDecl tree) {
1114             scan(tree.mods);
1115             scan(tree.restype);
1116             scan(tree.typarams);
1117             scan(tree.recvparam);
1118             scan(tree.params);
1119             scan(tree.thrown);
1120             scan(tree.defaultValue);
1121             // Do not annotate the body, just the signature.
1122         }
1123 
1124         @Override
1125         public void visitVarDef(JCVariableDecl tree) {
1126             DiagnosticPosition prevPos = deferPos;
1127             deferPos = tree.pos();
1128             try {
1129                 if (sym != null && sym.kind == VAR) {
1130                     // Don't visit a parameter once when the sym is the method
1131                     // and once when the sym is the parameter.
1132                     scan(tree.mods);
1133                     scan(tree.vartype);
1134                 }
1135                 scan(tree.init);
1136             } finally {
1137                 deferPos = prevPos;
1138             }
1139         }
1140 
1141         @Override
1142         public void visitBindingPattern(JCTree.JCBindingPattern tree) {
1143             //type binding pattern's type will be annotated separately, avoid
1144             //adding its annotations into the owning method here (would clash
1145             //with repeatable annotations).
1146         }
1147 
1148         @Override
1149         public void visitClassDef(JCClassDecl tree) {
1150             // We can only hit a classdef if it is declared within
1151             // a method. Ignore it - the class will be visited
1152             // separately later.
1153         }
1154 
1155         @Override
1156         public void visitNewClass(JCNewClass tree) {
1157             scan(tree.encl);
1158             scan(tree.typeargs);
1159             if (tree.def == null) {
1160                 scan(tree.clazz);
1161             }
1162             scan(tree.args);
1163             // the anonymous class instantiation if any will be visited separately.
1164         }
1165     }
1166 
1167     /*********************
1168      * Completer support *
1169      *********************/
1170 
1171     private AnnotationTypeCompleter theSourceCompleter = new AnnotationTypeCompleter() {
1172         @Override
1173         public void complete(ClassSymbol sym) throws CompletionFailure {
1174             Env<AttrContext> context = typeEnvs.get(sym);
1175             Annotate.this.attributeAnnotationType(context);
1176         }
1177     };
1178 
1179     /* Last stage completer to enter just enough annotations to have a prototype annotation type.
1180      * This currently means entering @Target and @Repeatable.
1181      */
1182     public AnnotationTypeCompleter annotationTypeSourceCompleter() {
1183         return theSourceCompleter;
1184     }
1185 
1186     private void attributeAnnotationType(Env<AttrContext> env) {
1187         Assert.check(((JCClassDecl)env.tree).sym.isAnnotationType(),
1188                 "Trying to annotation type complete a non-annotation type");
1189 
1190         JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
1191         try {
1192             JCClassDecl tree = (JCClassDecl)env.tree;
1193             AnnotationTypeVisitor v = new AnnotationTypeVisitor(attr, chk, syms, typeEnvs);
1194             v.scanAnnotationType(tree);
1195             tree.sym.getAnnotationTypeMetadata().setRepeatable(v.repeatable);
1196             tree.sym.getAnnotationTypeMetadata().setTarget(v.target);
1197         } finally {
1198             log.useSource(prev);
1199         }
1200     }
1201 
1202     public Attribute unfinishedDefaultValue() {
1203         return theUnfinishedDefaultValue;
1204     }
1205 
1206     public static interface AnnotationTypeCompleter {
1207         void complete(ClassSymbol sym) throws CompletionFailure;
1208     }
1209 
1210     /** Visitor to determine a prototype annotation type for a class declaring an annotation type.
1211      *
1212      *  <p><b>This is NOT part of any supported API.
1213      *  If you write code that depends on this, you do so at your own risk.
1214      *  This code and its internal interfaces are subject to change or
1215      *  deletion without notice.</b>
1216      */
1217     public class AnnotationTypeVisitor extends TreeScanner {
1218         private Env<AttrContext> env;
1219 
1220         private final Attr attr;
1221         private final Check check;
1222         private final Symtab tab;
1223         private final TypeEnvs typeEnvs;
1224 
1225         private Compound target;
1226         private Compound repeatable;
1227 
1228         public AnnotationTypeVisitor(Attr attr, Check check, Symtab tab, TypeEnvs typeEnvs) {
1229             this.attr = attr;
1230             this.check = check;
1231             this.tab = tab;
1232             this.typeEnvs = typeEnvs;
1233         }
1234 
1235         public Compound getRepeatable() {
1236             return repeatable;
1237         }
1238 
1239         public Compound getTarget() {
1240             return target;
1241         }
1242 
1243         public void scanAnnotationType(JCClassDecl decl) {
1244             visitClassDef(decl);
1245         }
1246 
1247         @Override
1248         public void visitClassDef(JCClassDecl tree) {
1249             Env<AttrContext> prevEnv = env;
1250             env = typeEnvs.get(tree.sym);
1251             try {
1252                 scan(tree.mods); // look for repeatable and target
1253                 // don't descend into body
1254             } finally {
1255                 env = prevEnv;
1256             }
1257         }
1258 
1259         @Override
1260         public void visitAnnotation(JCAnnotation tree) {
1261             Type t = tree.annotationType.type;
1262             if (t == null) {
1263                 t = attr.attribType(tree.annotationType, env);
1264                 tree.annotationType.type = t = check.checkType(tree.annotationType.pos(), t, tab.annotationType);
1265             }
1266 
1267             if (t == tab.annotationTargetType) {
1268                 target = Annotate.this.attributeAnnotation(tree, tab.annotationTargetType, env);
1269             } else if (t == tab.repeatableType) {
1270                 repeatable = Annotate.this.attributeAnnotation(tree, tab.repeatableType, env);
1271             }
1272         }
1273     }
1274 
1275     /** Represents the semantics of an Annotation Type.
1276      *
1277      *  <p><b>This is NOT part of any supported API.
1278      *  If you write code that depends on this, you do so at your own risk.
1279      *  This code and its internal interfaces are subject to change or
1280      *  deletion without notice.</b>
1281      */
1282     public static class AnnotationTypeMetadata {
1283         final ClassSymbol metaDataFor;
1284         private Compound target;
1285         private Compound repeatable;
1286         private AnnotationTypeCompleter annotationTypeCompleter;
1287 
1288         public AnnotationTypeMetadata(ClassSymbol metaDataFor, AnnotationTypeCompleter annotationTypeCompleter) {
1289             this.metaDataFor = metaDataFor;
1290             this.annotationTypeCompleter = annotationTypeCompleter;
1291         }
1292 
1293         private void init() {
1294             // Make sure metaDataFor is member entered
1295             while (!metaDataFor.isCompleted())
1296                 metaDataFor.complete();
1297 
1298             if (annotationTypeCompleter != null) {
1299                 AnnotationTypeCompleter c = annotationTypeCompleter;
1300                 annotationTypeCompleter = null;
1301                 c.complete(metaDataFor);
1302             }
1303         }
1304 
1305         public void complete() {
1306             init();
1307         }
1308 
1309         public Compound getRepeatable() {
1310             init();
1311             return repeatable;
1312         }
1313 
1314         public void setRepeatable(Compound repeatable) {
1315             Assert.checkNull(this.repeatable);
1316             this.repeatable = repeatable;
1317         }
1318 
1319         public Compound getTarget() {
1320             init();
1321             return target;
1322         }
1323 
1324         public void setTarget(Compound target) {
1325             Assert.checkNull(this.target);
1326                 this.target = target;
1327         }
1328 
1329         public Set<MethodSymbol> getAnnotationElements() {
1330             init();
1331             Set<MethodSymbol> members = new LinkedHashSet<>();
1332             WriteableScope s = metaDataFor.members();
1333             Iterable<Symbol> ss = s.getSymbols(NON_RECURSIVE);
1334             for (Symbol sym : ss)
1335                 if (sym.kind == MTH &&
1336                         sym.name != sym.name.table.names.clinit &&
1337                         (sym.flags() & SYNTHETIC) == 0)
1338                     members.add((MethodSymbol)sym);
1339             return members;
1340         }
1341 
1342         public Set<MethodSymbol> getAnnotationElementsWithDefault() {
1343             init();
1344             Set<MethodSymbol> members = getAnnotationElements();
1345             Set<MethodSymbol> res = new LinkedHashSet<>();
1346             for (MethodSymbol m : members)
1347                 if (m.defaultValue != null)
1348                     res.add(m);
1349             return res;
1350         }
1351 
1352         @Override
1353         public String toString() {
1354             return "Annotation type for: " + metaDataFor;
1355         }
1356 
1357         public boolean isMetadataForAnnotationType() { return true; }
1358 
1359         public static AnnotationTypeMetadata notAnAnnotationType() {
1360             return NOT_AN_ANNOTATION_TYPE;
1361         }
1362 
1363         private static final AnnotationTypeMetadata NOT_AN_ANNOTATION_TYPE =
1364                 new AnnotationTypeMetadata(null, null) {
1365                     @Override
1366                     public void complete() {
1367                     } // do nothing
1368 
1369                     @Override
1370                     public String toString() {
1371                         return "Not an annotation type";
1372                     }
1373 
1374                     @Override
1375                     public Set<MethodSymbol> getAnnotationElements() {
1376                         return new LinkedHashSet<>(0);
1377                     }
1378 
1379                     @Override
1380                     public Set<MethodSymbol> getAnnotationElementsWithDefault() {
1381                         return new LinkedHashSet<>(0);
1382                     }
1383 
1384                     @Override
1385                     public boolean isMetadataForAnnotationType() {
1386                         return false;
1387                     }
1388 
1389                     @Override
1390                     public Compound getTarget() {
1391                         return null;
1392                     }
1393 
1394                     @Override
1395                     public Compound getRepeatable() {
1396                         return null;
1397                     }
1398                 };
1399     }
1400 
1401     public void newRound() {
1402         blockCount = 1;
1403     }
1404 
1405     public Queues setQueues(Queues nue) {
1406         Queues stored = new Queues(q, validateQ, typesQ, afterTypesQ);
1407         this.q = nue.q;
1408         this.typesQ = nue.typesQ;
1409         this.afterTypesQ = nue.afterTypesQ;
1410         this.validateQ = nue.validateQ;
1411         return stored;
1412     }
1413 
1414     static class Queues {
1415         private final ListBuffer<Runnable> q;
1416         private final ListBuffer<Runnable> validateQ;
1417         private final ListBuffer<Runnable> typesQ;
1418         private final ListBuffer<Runnable> afterTypesQ;
1419 
1420         public Queues() {
1421             this(new ListBuffer<Runnable>(), new ListBuffer<Runnable>(), new ListBuffer<Runnable>(), new ListBuffer<Runnable>());
1422         }
1423 
1424         public Queues(ListBuffer<Runnable> q, ListBuffer<Runnable> validateQ, ListBuffer<Runnable> typesQ, ListBuffer<Runnable> afterTypesQ) {
1425             this.q = q;
1426             this.validateQ = validateQ;
1427             this.typesQ = typesQ;
1428             this.afterTypesQ = afterTypesQ;
1429         }
1430     }
1431 }