jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Attr.java

-:19e8eebfbe52
+:b0c086cd4520
 // Tree<Point>.Visitor.
 else if (ownOuter.hasTag(CLASS) && site != ownOuter) {
 Type normOuter = site;
 if (normOuter.hasTag(CLASS)) {
 normOuter = types.asEnclosingSuper(site, ownOuter.tsym);
-if (site.isAnnotated()) {
-// Propagate any type annotations.
-// TODO: should asEnclosingSuper do this?
-// Note that the type annotations in site will be updated
-// by annotateType. Therefore, modify site instead
-// of creating a new AnnotatedType.
-((AnnotatedType)site).underlyingType = normOuter;
-normOuter = site;
-}
 }
 if (normOuter == null) // perhaps from an import
 normOuter = types.erasure(ownOuter);
 if (normOuter != ownOuter)
 owntype = new ClassType(
 site = types.erasure(clazzOuter);
 clazzOuter = site;
 }
 }
 owntype = new ClassType(clazzOuter, actuals, clazztype.tsym);
-if (clazztype.isAnnotated()) {
-// Use the same AnnotatedType, because it will have
-// its annotations set later.
-((AnnotatedType)clazztype).underlyingType = owntype;
-owntype = clazztype;
-}
 } else {
 if (formals.length() != 0) {
 log.error(tree.pos(), "wrong.number.type.args",
 Integer.toString(formals.length()));
 } else {
 public void visitTypeParameter(JCTypeParameter tree) {
 TypeVar typeVar = (TypeVar) tree.type;
 if (tree.annotations != null && tree.annotations.nonEmpty()) {
-AnnotatedType antype = new AnnotatedType(typeVar);
+annotateType(tree, tree.annotations);
-annotateType(antype, tree.annotations);
-tree.type = antype;
 }
 if (!typeVar.bound.isErroneous()) {
 //fixup type-parameter bound computed in 'attribTypeVariables'
 typeVar.bound = checkIntersection(tree, tree.bounds);
 }
 public void visitAnnotatedType(JCAnnotatedType tree) {
 Type underlyingType = attribType(tree.getUnderlyingType(), env);
 this.attribAnnotationTypes(tree.annotations, env);
-AnnotatedType antype = new AnnotatedType(underlyingType);
+annotateType(tree, tree.annotations);
-annotateType(antype, tree.annotations);
+result = tree.type = underlyingType;
-result = tree.type = antype;
 }
 /**
 * Apply the annotations to the particular type.
 */
-public void annotateType(final AnnotatedType type, final List<JCAnnotation> annotations) {
+public void annotateType(final JCTree tree, final List<JCAnnotation> annotations) {
-if (annotations.isEmpty())
+// Callers ensure this.
-return;
+// Assert.check(annotations != null && annotations.nonEmpty());
 annotate.typeAnnotation(new Annotate.Worker() {
 @Override
 public String toString() {
-return "annotate " + annotations + " onto " + type;
+return "annotate " + annotations + " onto " + tree;
 }
 @Override
 public void run() {
 List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
-type.typeAnnotations = compounds;
+if (annotations.size() == compounds.size()) {
+// All annotations were successfully converted into compounds
+tree.type = tree.type.unannotatedType().annotatedType(compounds);
+}
 }
 });
 }
 private static List<Attribute.TypeCompound> fromAnnotations(List<JCAnnotation> annotations) {
 }
 //where
 private final class TypeAnnotationsValidator extends TreeScanner {
 private final boolean sigOnly;
-private boolean checkAllAnnotations = false;
 public TypeAnnotationsValidator(boolean sigOnly) {
 this.sigOnly = sigOnly;
 }
 public void visitAnnotation(JCAnnotation tree) {
-if (tree.hasTag(TYPE_ANNOTATION) || checkAllAnnotations) {
+chk.validateTypeAnnotation(tree, false);
-chk.validateTypeAnnotation(tree, false);
-}
 super.visitAnnotation(tree);
+}
+public void visitAnnotatedType(JCAnnotatedType tree) {
+if (!tree.underlyingType.type.isErroneous()) {
+super.visitAnnotatedType(tree);
+}
 }
 public void visitTypeParameter(JCTypeParameter tree) {
 chk.validateTypeAnnotations(tree.annotations, true);
 scan(tree.bounds);
 // Don't call super.
 scan(tree.body);
 }
 }
 public void visitVarDef(final JCVariableDecl tree) {
 if (tree.sym != null && tree.sym.type != null)
-validateAnnotatedType(tree, tree.sym.type);
+validateAnnotatedType(tree.vartype, tree.sym.type);
 scan(tree.mods);
 scan(tree.vartype);
 if (!sigOnly) {
 scan(tree.init);
 }
 if (tree.clazz != null && tree.clazz.type != null)
 validateAnnotatedType(tree.clazz, tree.clazz.type);
 super.visitTypeTest(tree);
 }
 public void visitNewClass(JCNewClass tree) {
-if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
+if (tree.clazz.type != null)
-boolean prevCheck = this.checkAllAnnotations;
+validateAnnotatedType(tree.clazz, tree.clazz.type);
-try {
-this.checkAllAnnotations = true;
-scan(((JCAnnotatedType)tree.clazz).annotations);
-} finally {
-this.checkAllAnnotations = prevCheck;
-}
-}
 super.visitNewClass(tree);
 }
 public void visitNewArray(JCNewArray tree) {
-if (tree.elemtype != null && tree.elemtype.hasTag(ANNOTATED_TYPE)) {
+if (tree.elemtype != null && tree.elemtype.type != null)
-boolean prevCheck = this.checkAllAnnotations;
+validateAnnotatedType(tree.elemtype, tree.elemtype.type);
-try {
-this.checkAllAnnotations = true;
-scan(((JCAnnotatedType)tree.elemtype).annotations);
-} finally {
-this.checkAllAnnotations = prevCheck;
-}
-}
 super.visitNewArray(tree);
 }
 @Override
 public void visitClassDef(JCClassDecl tree) {
 * of the symbol.
 * Therefore, we need to override each individual location where a type
 * can occur.
 */
 private void validateAnnotatedType(final JCTree errtree, final Type type) {
-if (type.getEnclosingType() != null &&
+// System.out.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
-type != type.getEnclosingType()) {
-validateEnclosingAnnotatedType(errtree, type.getEnclosingType());
+if (type.isPrimitiveOrVoid()) {
-}
+return;
-for (Type targ : type.getTypeArguments()) {
+}
-validateAnnotatedType(errtree, targ);
-}
+JCTree enclTr = errtree;
-}
+Type enclTy = type;
-private void validateEnclosingAnnotatedType(final JCTree errtree, final Type type) {
-validateAnnotatedType(errtree, type);
+boolean repeat = true;
-if (type.tsym != null &&
+while (repeat) {
-type.tsym.isStatic() &&
+if (enclTr.hasTag(TYPEAPPLY)) {
-type.getAnnotationMirrors().nonEmpty()) {
+List<Type> tyargs = enclTy.getTypeArguments();
-// Enclosing static classes cannot have type annotations.
+List<JCExpression> trargs = ((JCTypeApply)enclTr).getTypeArguments();
-log.error(errtree.pos(), "cant.annotate.static.class");
+if (trargs.length() > 0) {
+// Nothing to do for diamonds
+if (tyargs.length() == trargs.length()) {
+for (int i = 0; i < tyargs.length(); ++i) {
+validateAnnotatedType(trargs.get(i), tyargs.get(i));
+}
+}
+// If the lengths don't match, it's either a diamond
+// or some nested type that redundantly provides
+// type arguments in the tree.
+}
+// Look at the clazz part of a generic type
+enclTr = ((JCTree.JCTypeApply)enclTr).clazz;
+}
+if (enclTr.hasTag(SELECT)) {
+enclTr = ((JCTree.JCFieldAccess)enclTr).getExpression();
+if (enclTy != null &&
+!enclTy.hasTag(NONE)) {
+enclTy = enclTy.getEnclosingType();
+}
+} else if (enclTr.hasTag(ANNOTATED_TYPE)) {
+JCAnnotatedType at = (JCTree.JCAnnotatedType) enclTr;
+if (enclTy == null ||
+enclTy.hasTag(NONE)) {
+if (at.getAnnotations().size() == 1) {
+log.error(at.underlyingType.pos(), "cant.type.annotate.scoping.1", at.getAnnotations().head.attribute);
+} else {
+ListBuffer<Attribute.Compound> comps = new ListBuffer<Attribute.Compound>();
+for (JCAnnotation an : at.getAnnotations()) {
+comps.add(an.attribute);
+}
+log.error(at.underlyingType.pos(), "cant.type.annotate.scoping", comps.toList());
+}
+repeat = false;
+}
+enclTr = at.underlyingType;
+// enclTy doesn't need to be changed
+} else if (enclTr.hasTag(IDENT)) {
+repeat = false;
+} else if (enclTr.hasTag(JCTree.Tag.WILDCARD)) {
+JCWildcard wc = (JCWildcard) enclTr;
+if (wc.getKind() == JCTree.Kind.EXTENDS_WILDCARD) {
+validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy.unannotatedType()).getExtendsBound());
+} else if (wc.getKind() == JCTree.Kind.SUPER_WILDCARD) {
+validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy.unannotatedType()).getSuperBound());
+} else {
+// Nothing to do for UNBOUND
+}
+repeat = false;
+} else if (enclTr.hasTag(TYPEARRAY)) {
+JCArrayTypeTree art = (JCArrayTypeTree) enclTr;
+validateAnnotatedType(art.getType(), ((ArrayType)enclTy.unannotatedType()).getComponentType());
+repeat = false;
+} else if (enclTr.hasTag(TYPEUNION)) {
+JCTypeUnion ut = (JCTypeUnion) enclTr;
+for (JCTree t : ut.getTypeAlternatives()) {
+validateAnnotatedType(t, t.type);
+}
+repeat = false;
+} else if (enclTr.hasTag(TYPEINTERSECTION)) {
+JCTypeIntersection it = (JCTypeIntersection) enclTr;
+for (JCTree t : it.getBounds()) {
+validateAnnotatedType(t, t.type);
+}
+repeat = false;
+} else if (enclTr.getKind() == JCTree.Kind.PRIMITIVE_TYPE) {
+// This happens in test TargetTypeTest52.java
+// Is there anything to do?
+repeat = false;
+} else {
+Assert.error("Unexpected tree: " + enclTr + " with kind: " + enclTr.getKind() +
+" within: "+ errtree + " with kind: " + errtree.getKind());
+}
 }
 }
 };
 // <editor-fold desc="post-attribution visitor">

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Attr.java

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