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

equal deleted inserted replaced

-:57913337d634
+:f3bec12a63e7
 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.
 *
 }
 Attribute enterAttributeValue(Type expected,
 JCExpression tree,
 Env<AttrContext> env) {
-Type original = expected;
 //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();
 for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {
 enterAttributeValue(syms.errType,
 l.head,
 env);
 }
-return new Attribute.Error(original);
+return new Attribute.Error(syms.errType);
 }
 if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {
 if (tree.hasTag(ANNOTATION)) {
 return enterAnnotation((JCAnnotation)tree, expected, env);
 } else {
 }
 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(original);
+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(expected);
+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 a class literal?
+// Does it look like an unresolved class literal?
-if (TreeInfo.name(tree) == names._class) {
+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(expected);
+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(expected);
+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) {
-attr.attribExpr(tree, env, expected);
+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(expected);
+return new Attribute.Error(result.getOriginalType());
 }
 VarSymbol enumerator = (VarSymbol) sym;
 return new Attribute.Enum(expected, enumerator);
 }
 //error recovery:

changeset 21015	f3bec12a63e7
parent 20599	5201f7144a3c
child 21018	95d225149128