src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TypeEnter.java

@@ -34,10 +34,11 @@
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Scope.ImportFilter;
 import com.sun.tools.javac.code.Scope.NamedImportScope;
 import com.sun.tools.javac.code.Scope.StarImportScope;
 import com.sun.tools.javac.code.Scope.WriteableScope;
+import com.sun.tools.javac.comp.Annotate.AnnotationTypeMetadata;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.DefinedBy.Api;
 
 import com.sun.tools.javac.code.Symbol.*;

@@ -133,10 +134,11 @@
         source = Source.instance(context);
         deferredLintHandler = DeferredLintHandler.instance(context);
         lint = Lint.instance(context);
         typeEnvs = TypeEnvs.instance(context);
         dependencies = Dependencies.instance(context);
+        Source source = Source.instance(context);
         allowTypeAnnos = source.allowTypeAnnotations();
         allowDeprecationOnImport = source.allowDeprecationOnImport();
     }
 
     /** Switch: support type annotations.

@@ -182,11 +184,11 @@
             sym.completer = this;
             return;
         }
 
         try {
-            annotate.enterStart();
+            enter.enterStart();
             sym.flags_field |= UNATTRIBUTED;
 
             List<Env<AttrContext>> queue;
 
             dependencies.push((ClassSymbol) sym, CompletionCause.MEMBER_ENTER);

@@ -204,11 +206,11 @@
                         finishImports(env.toplevel, () -> {});
                     }
                 }
             }
         } finally {
-            annotate.enterDone();
+            enter.enterDone();
         }
     }
 
     void finishImports(JCCompilationUnit toplevel, Runnable resolve) {
         JavaFileObject prev = log.useSource(toplevel.sourcefile);

@@ -782,13 +784,13 @@
 
             // create an environment for evaluating the base clauses
             Env<AttrContext> baseEnv = baseEnv(tree, env);
 
             if (tree.extending != null)
-                annotate.annotateTypeLater(tree.extending, baseEnv, sym, tree.pos());
+                annotate.queueScanTreeAndTypeAnnotate(tree.extending, baseEnv, sym, tree.pos());
             for (JCExpression impl : tree.implementing)
-                annotate.annotateTypeLater(impl, baseEnv, sym, tree.pos());
+                annotate.queueScanTreeAndTypeAnnotate(impl, baseEnv, sym, tree.pos());
             annotate.flush();
 
             attribSuperTypes(env, baseEnv);
 
             Set<Type> interfaceSet = new HashSet<>();

@@ -802,11 +804,11 @@
             annotate.annotateLater(tree.mods.annotations, baseEnv,
                         sym, tree.pos());
 
             attr.attribTypeVariables(tree.typarams, baseEnv);
             for (JCTypeParameter tp : tree.typarams)
-                annotate.annotateTypeLater(tp, baseEnv, sym, tree.pos());
+                annotate.queueScanTreeAndTypeAnnotate(tp, baseEnv, sym, tree.pos());
 
             // check that no package exists with same fully qualified name,
             // but admit classes in the unnamed package which have the same
             // name as a top-level package.
             if (checkClash &&

@@ -901,10 +903,15 @@
             if ((tree.mods.flags & Flags.ENUM) != 0 &&
                 (types.supertype(tree.sym.type).tsym.flags() & Flags.ENUM) == 0) {
                 addEnumMembers(tree, env);
             }
             memberEnter.memberEnter(tree.defs, env);
+
+            if (tree.sym.isAnnotationType()) {
+                Assert.checkNull(tree.sym.completer);
+                tree.sym.setAnnotationTypeMetadata(new AnnotationTypeMetadata(tree.sym, annotate.annotationTypeSourceCompleter()));
+            }
         }
 
         /** Add the implicit members for an enum type
          *  to the symbol table.
          */