From 70dfea7408041c704df1de2b9f00cc68d97c136d Mon Sep 17 00:00:00 2001 From: jfranck Date: Tue, 20 Aug 2013 17:21:47 +0200 Subject: [PATCH] 8019243: AnnotationTypeMismatchException instead of MirroredTypeException Reviewed-by: jjg --- .../com/sun/tools/javac/code/Attribute.java | 8 ++ .../com/sun/tools/javac/comp/Annotate.java | 16 ++- .../javac/model/AnnotationProxyMaker.java | 5 +- .../Processor.java | 100 ++++++++++++++++++ .../EnsureMirroredTypeException/Source.java | 17 +++ .../EnsureMirroredTypeException/Source.out | 4 + 6 files changed, 147 insertions(+), 3 deletions(-) create mode 100644 test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java create mode 100644 test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java create mode 100644 test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.out diff --git a/src/share/classes/com/sun/tools/javac/code/Attribute.java b/src/share/classes/com/sun/tools/javac/code/Attribute.java index bb29eeaa..990ea0d0 100644 --- a/src/share/classes/com/sun/tools/javac/code/Attribute.java +++ b/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); diff --git a/src/share/classes/com/sun/tools/javac/comp/Annotate.java b/src/share/classes/com/sun/tools/javac/comp/Annotate.java index 39587558..3a0997be 100644 --- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java +++ b/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); diff --git a/src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java b/src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java index e44f6734..d58c73fa 100644 --- a/src/share/classes/com/sun/tools/javac/model/AnnotationProxyMaker.java +++ b/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 } diff --git a/test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java new file mode 100644 index 00000000..71e722ef --- /dev/null +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Processor.java @@ -0,0 +1,100 @@ +/* + * 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 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(); + } +} diff --git a/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java new file mode 100644 index 00000000..0f66b6d0 --- /dev/null +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.java @@ -0,0 +1,17 @@ +/* + * @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{} diff --git a/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.out b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.out new file mode 100644 index 00000000..9e2aafb6 --- /dev/null +++ b/test/tools/javac/processing/errors/EnsureMirroredTypeException/Source.out @@ -0,0 +1,4 @@ +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 -- GitLab