8019243: AnnotationTypeMismatchException instead of MirroredTypeException

Reviewed-by: jjg

src/share/classes/com/sun/tools/javac/code/Attribute.java

@@ -340,6 +340,14 @@ public abstract class Attribute implements AnnotationValue {
         }
     }
 
+    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 {
         void visitConstant(Attribute.Constant value);

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

@@ -332,8 +332,20 @@ public class Annotate {
         }
         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 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);

src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java

@@ -244,7 +244,10 @@ public class AnnotationProxyMaker {
         }
 
         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
         }
 
 

test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java

+/*
+ * 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.
+ */
+
+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<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        for (Element e : roundEnv.getElementsAnnotatedWith(A.class)) {
+            A rtg = e.getAnnotation(A.class);
+
+            try {
+                rtg.a();
+                Assert.check(false); //Should not reach here
+            } catch (MirroredTypeException ex) {
+                TypeMirror tm = ex.getTypeMirror();
+                Assert.check(tm.getKind() == TypeKind.ERROR);
+
+                TypeElement elm = (TypeElement)((DeclaredType)tm).asElement();
+                Assert.check(elm.getQualifiedName().toString().
+                        endsWith("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();
+                Assert.check(false); //Should not reach here
+            } catch (MirroredTypeException ex) {
+                TypeMirror tm = ex.getTypeMirror();
+                Assert.check(tm.getKind() == TypeKind.ERROR);
+
+                TypeElement elm = (TypeElement)((DeclaredType)tm).asElement();
+                Assert.check(elm.getQualifiedName().toString().
+                        endsWith("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();
+    }
+}

test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java

+/*
+ * @test /nodynamiccopyright/
+ * @bug 8019243
+ * @summary AnnotationTypeMismatchException instead of MirroredTypeException
+ * @library /tools/javac/lib
+ * @build JavacTestingAbstractProcessor Processor
+ * @compile/fail/ref=Source.out -XDrawDiagnostics -processor Processor Source.java
+ */
+
+@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{}

test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.out

+Source.java:10:28: compiler.err.doesnt.exist: some.path.to
+Source.java:13:16: compiler.err.cant.resolve: kindname.class, SomeUnknownClass, , 
+Source.java:16:16: compiler.err.cant.resolve: kindname.variable, SomeUnknownClass, , 
+3 errors