diff -r af80273f630a src/share/classes/com/sun/tools/javac/code/Attribute.java --- a/src/share/classes/com/sun/tools/javac/code/Attribute.java Mon Aug 12 17:28:31 2013 +0100 +++ b/src/share/classes/com/sun/tools/javac/code/Attribute.java Tue Aug 13 17:10:08 2013 +0200 @@ -339,6 +339,14 @@ return v.visitString(toString(), p); } } + + public static class UnresolvedClass extends Error { + public Type classType; + public UnresolvedClass(Type type, Type classType) { + super(type); + this.classType = classType; + } + } /** A visitor type for dynamic dispatch on the kind of attribute value. */ public static interface Visitor { diff -r af80273f630a src/share/classes/com/sun/tools/javac/comp/Annotate.java --- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java Mon Aug 12 17:28:31 2013 +0100 +++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java Tue Aug 13 17:10:08 2013 +0200 @@ -332,8 +332,20 @@ } if (expected.tsym == syms.classType.tsym) { Type result = attr.attribExpr(tree, env, expected); - if (result.isErroneous()) - return new Attribute.Error(expected); + if (result.isErroneous()) { + // Does it look like a class literal? + if (TreeInfo.name(tree) == names._class) { + 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); + } + } + + // Class litterals 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); diff -r af80273f630a src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java --- a/src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java Mon Aug 12 17:28:31 2013 +0100 +++ b/src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java Tue Aug 13 17:10:08 2013 +0200 @@ -244,7 +244,10 @@ } public void visitError(Attribute.Error e) { - value = null; // indicates a type mismatch + if (e instanceof Attribute.UnresolvedClass) + value = new MirroredTypeExceptionProxy(((Attribute.UnresolvedClass)e).classType); + else + value = null; // indicates a type mismatch } diff -r af80273f630a test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java Tue Aug 13 17:10:08 2013 +0200 @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8019243 + * @summary AnnotationTypeMismatchException instead of MirroredTypeException + * @library /tools/javac/lib + * @build JavacTestingAbstractProcessor Processor + * @compile/fail/ref=Processor.out -classpath . -XDrawDiagnostics -processor Processor Source.java + */ +import java.lang.annotation.*; +import java.util.*; +import javax.annotation.processing.*; +import javax.lang.model.element.*; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.MirroredTypeException; +import javax.lang.model.type.TypeMirror; +import javax.lang.model.type.TypeKind; +import javax.tools.*; + +import com.sun.tools.javac.util.Assert; +import com.sun.tools.javac.code.Symbol; +import static com.sun.tools.javac.code.Symbol.TypeSymbol; + +public class Processor extends JavacTestingAbstractProcessor { + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + for (Element e : roundEnv.getElementsAnnotatedWith(A.class)) { + A rtg = e.getAnnotation(A.class); + + try { + rtg.a(); + } catch (MirroredTypeException ex) { + TypeMirror tm = ex.getTypeMirror(); + Assert.check(tm.getKind() == TypeKind.ERROR); + + TypeElement elm = (TypeElement)((DeclaredType)tm).asElement(); + Assert.check(elm.getQualifiedName().contentEquals(".some.path.to.SomeUnknownClass$Inner")); + + TypeSymbol sym = (TypeSymbol)elm; + Assert.check(sym.name.contentEquals("some.path.to.SomeUnknownClass$Inner")); + } + } + for (Element e : roundEnv.getElementsAnnotatedWith(B.class)) { + B rtg = e.getAnnotation(B.class); + + try { + rtg.a(); + } catch (MirroredTypeException ex) { + TypeMirror tm = ex.getTypeMirror(); + Assert.check(tm.getKind() == TypeKind.ERROR); + + TypeElement elm = (TypeElement)((DeclaredType)tm).asElement(); + Assert.check(elm.getQualifiedName().contentEquals(".SomeUnknownClass")); + + TypeSymbol sym = (TypeSymbol)elm; + Assert.check(sym.name.contentEquals("SomeUnknownClass")); + } + } + for (Element e : roundEnv.getElementsAnnotatedWith(C.class)) { + C rtg = e.getAnnotation(C.class); + + try { + rtg.a(); + Assert.check(false); //Should not reach here + } catch (AnnotationTypeMismatchException ex) { + ; + } + } + return true; + } + + @interface A { + Class a(); + } + @interface B { + Class a(); + } + @interface C { + Class a(); + } +} diff -r af80273f630a test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.out Tue Aug 13 17:10:08 2013 +0200 @@ -0,0 +1,4 @@ +Source.java:24:28: compiler.err.doesnt.exist: some.path.to +Source.java:27:16: compiler.err.cant.resolve: kindname.class, SomeUnknownClass, , +Source.java:30:16: compiler.err.cant.resolve: kindname.variable, SomeUnknownClass, , +3 errors diff -r af80273f630a test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java Tue Aug 13 17:10:08 2013 +0200 @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +/* /nodynamiccopyright/ */ +@Processor.A(a=some.path.to.SomeUnknownClass$Inner.class) +class Source1{} + +@Processor.B(a=SomeUnknownClass.class) +class Source2{} + +@Processor.C(a=SomeUnknownClass.clas) // this is not a class literal +class Source3{}