jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java

equal deleted inserted replaced

-:85d4f5471a74
+:826ac2519523
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Scope.WriteableScope;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
+import com.sun.tools.javac.code.TypeMetadata.Annotations;
 import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;
 import com.sun.tools.javac.comp.Check.CheckContext;
 import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
 import com.sun.tools.javac.comp.Infer.InferenceContext;
 import com.sun.tools.javac.comp.Infer.FreeTypeListener;
 final ConstFold cfolder;
 final Enter enter;
 final Target target;
 final Types types;
 final JCDiagnostic.Factory diags;
-final Annotate annotate;
 final TypeAnnotations typeAnnotations;
 final DeferredLintHandler deferredLintHandler;
 final TypeEnvs typeEnvs;
 final Dependencies dependencies;
+final Annotate annotate;
 public static Attr instance(Context context) {
 Attr instance = context.get(attrKey);
 if (instance == null)
 instance = new Attr(context);
 env.enclClass.sym);
 }
 }
 // Attribute all type annotations in the body
-annotate.annotateTypeLater(tree.body, localEnv, m, null);
+annotate.queueScanTreeAndTypeAnnotate(tree.body, localEnv, m, null);
 annotate.flush();
 // Attribute method body.
 attribStat(tree.body, localEnv);
 }
 if (tree.sym != null) {
 // parameters have already been entered
 env.info.scope.enter(tree.sym);
 } else {
 try {
-annotate.enterStart();
+annotate.blockAnnotations();
 memberEnter.memberEnter(tree, env);
 } finally {
-annotate.enterDone();
+annotate.unblockAnnotations();
 }
 }
 } else {
 if (tree.init != null) {
 // Field initializer expression need to be entered.
-annotate.annotateTypeLater(tree.init, env, tree.sym, tree.pos());
+annotate.queueScanTreeAndTypeAnnotate(tree.init, env, tree.sym, tree.pos());
 annotate.flush();
 }
 }
 VarSymbol v = tree.sym;
 final Env<AttrContext> localEnv =
 env.dup(tree, env.info.dup(env.info.scope.dupUnshared(fakeOwner)));
 if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;
 // Attribute all type annotations in the block
-annotate.annotateTypeLater(tree, localEnv, localEnv.info.scope.owner, null);
+annotate.queueScanTreeAndTypeAnnotate(tree, localEnv, localEnv.info.scope.owner, null);
 annotate.flush();
 attribStats(tree.stats, localEnv);
 {
 // Store init and clinit type annotations with the ClassSymbol
 clazz = clazzid1;
 }
 // Attribute clazz expression and store
 // symbol + type back into the attributed tree.
-Type clazztype = TreeInfo.isEnumInit(env.tree) ?
+Type clazztype;
-attribIdentAsEnumType(env, (JCIdent)clazz) :
-attribType(clazz, env);
+try {
+env.info.isNewClass = true;
+clazztype = TreeInfo.isEnumInit(env.tree) ?
+attribIdentAsEnumType(env, (JCIdent)clazz) :
+attribType(clazz, env);
+} finally {
+env.info.isNewClass = false;
+}
 clazztype = chk.checkDiamond(tree, clazztype);
 chk.validate(clazz, localEnv);
 if (tree.encl != null) {
 // We have to work in this case to store
 public void visitTypeParameter(JCTypeParameter tree) {
 TypeVar typeVar = (TypeVar) tree.type;
 if (tree.annotations != null && tree.annotations.nonEmpty()) {
-annotateType(tree, tree.annotations);
+annotate.annotateTypeParameterSecondStage(tree, tree.annotations);
 }
 if (!typeVar.bound.isErroneous()) {
 //fixup type-parameter bound computed in 'attribTypeVariables'
 typeVar.bound = checkIntersection(tree, tree.bounds);
 syms.boundClass),
 KindSelector.TYP, resultInfo);
 }
 public void visitAnnotation(JCAnnotation tree) {
-Assert.error("should be handled in Annotate");
+Assert.error("should be handled in annotate");
 }
 public void visitAnnotatedType(JCAnnotatedType tree) {
-Type underlyingType = attribType(tree.getUnderlyingType(), env);
+attribAnnotationTypes(tree.annotations, env);
-this.attribAnnotationTypes(tree.annotations, env);
+Type underlyingType = attribType(tree.underlyingType, env);
-annotateType(tree, tree.annotations);
+Type annotatedType = underlyingType.annotatedType(Annotations.TO_BE_SET);
-result = tree.type = underlyingType;
-}
+if (!env.info.isNewClass)
+annotate.annotateTypeSecondStage(tree, tree.annotations, annotatedType);
-/**
+result = tree.type = annotatedType;
-* Apply the annotations to the particular type.
-*/
-public void annotateType(final JCTree tree, final List<JCAnnotation> annotations) {
-annotate.typeAnnotation(new Annotate.Worker() {
-@Override
-public String toString() {
-return "annotate " + annotations + " onto " + tree;
-}
-@Override
-public void run() {
-List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
-Assert.check(annotations.size() == compounds.size());
-tree.type = tree.type.annotatedType(compounds);
-}
-});
-}
-private static List<Attribute.TypeCompound> fromAnnotations(List<JCAnnotation> annotations) {
-if (annotations.isEmpty()) {
-return List.nil();
-}
-ListBuffer<Attribute.TypeCompound> buf = new ListBuffer<>();
-for (JCAnnotation anno : annotations) {
-Assert.checkNonNull(anno.attribute);
-buf.append((Attribute.TypeCompound) anno.attribute);
-}
-return buf.toList();
 }
 public void visitErroneous(JCErroneous tree) {
 if (tree.errs != null)
 for (JCTree err : tree.errs)
 "cant.extend.intf.annotation");
 if (tree.typarams.nonEmpty())
 log.error(tree.typarams.head.pos(),
 "intf.annotation.cant.have.type.params");
-// If this annotation has a @Repeatable, validate
+// If this annotation type has a @Repeatable, validate
-Attribute.Compound repeatable = c.attribute(syms.repeatableType.tsym);
+Attribute.Compound repeatable = c.getAnnotationTypeMetadata().getRepeatable();
+// If this annotation type has a @Repeatable, validate
 if (repeatable != null) {
 // get diagnostic position for error reporting
 DiagnosticPosition cbPos = getDiagnosticPosition(tree, repeatable.type);
 Assert.checkNonNull(cbPos);
 // Note that a tree type might be an AnnotatedType with
 // empty annotations, if only declaration annotations were given.
 // This method will raise an error for such a type.
 for (JCAnnotation ai : annotations) {
 if (!ai.type.isErroneous() &&
-typeAnnotations.annotationType(ai.attribute, sym) == TypeAnnotations.AnnotationType.DECLARATION) {
+typeAnnotations.annotationTargetType(ai.attribute, sym) == TypeAnnotations.AnnotationType.DECLARATION) {
 log.error(ai.pos(), "annotation.type.not.applicable");
 }
 }
 }
 }

changeset 29842	826ac2519523
parent 29776	984a79b71cfe
child 29959	61bfc66866da