archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-19 18:44:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8026564: import changes from type-annotations forest

Browse source 
Co-authored-by: Steve Sides <steve.sides@oracle.com>
Reviewed-by: jjg
This commit is contained in:
Werner Dietl 2013-10-15 15:57:13 -07:00 • committed by Jonathan Gibbons
parent 912fc38c65
commit e5c34a89eb
61 changed files with 1173 additions and 298 deletions
Download patch file Download diff file Expand all files Collapse all files

4
langtools/make/build.properties
View file

@ -163,11 +163,11 @@ javap.tests = \
#
sjavac.includes = \
com/sun/tools/sjavac/
com/sun/tools/sjavac/
sjavac.tests = \
tools/sjavac
#
# The following files require the latest JDK to be available.

2
langtools/make/build.xml
View file

@ -89,7 +89,7 @@
build-classes-TOOL build the classes for the tool
build-TOOL build the jar file and script for the tool
jtreg-TOOL build the tool and run the appropriate tests
findbugs-TOOL run findbugs on the tool's source oode
findbugs-TOOL run findbugs on the tool's source code
TOOL build the tool, run the tests, and run findbugs
- utility definitions
-->

3
langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java
View file

@ -236,6 +236,7 @@ public abstract class Attribute implements AnnotationValue {
public static class TypeCompound extends Compound {
public TypeAnnotationPosition position;
public TypeCompound(Compound compound,
TypeAnnotationPosition position) {
this(compound.type, compound.values, position);
@ -256,7 +257,7 @@ public abstract class Attribute implements AnnotationValue {
}
public boolean hasUnknownPosition() {
return position == null || position.type == TargetType.UNKNOWN;
return position.type == TargetType.UNKNOWN;
}
public boolean isContainerTypeCompound() {

19
langtools/src/share/classes/com/sun/tools/javac/code/Printer.java
View file

@ -260,24 +260,23 @@ public abstract class Printer implements Type.Visitor<String, Locale>, Symbol.Vi
@Override
public String visitAnnotatedType(AnnotatedType t, Locale locale) {
if (t.typeAnnotations != null &&
t.typeAnnotations.nonEmpty()) {
if (t.underlyingType.hasTag(TypeTag.ARRAY)) {
if (t.getAnnotationMirrors().nonEmpty()) {
if (t.unannotatedType().hasTag(TypeTag.ARRAY)) {
StringBuilder res = new StringBuilder();
printBaseElementType(t, res, locale);
printBrackets(t, res, locale);
return res.toString();
} else if (t.underlyingType.hasTag(TypeTag.CLASS) &&
t.underlyingType.getEnclosingType() != Type.noType) {
return visit(t.underlyingType.getEnclosingType(), locale) +
} else if (t.unannotatedType().hasTag(TypeTag.CLASS) &&
t.unannotatedType().getEnclosingType() != Type.noType) {
return visit(t.unannotatedType().getEnclosingType(), locale) +
". " +
t.typeAnnotations +
" " + className((ClassType)t.underlyingType, false, locale);
t.getAnnotationMirrors() +
" " + className((ClassType)t.unannotatedType(), false, locale);
} else {
return t.typeAnnotations + " " + visit(t.underlyingType, locale);
return t.getAnnotationMirrors() + " " + visit(t.unannotatedType(), locale);
}
} else {
return visit(t.underlyingType, locale);
return visit(t.unannotatedType(), locale);
}
}

2
langtools/src/share/classes/com/sun/tools/javac/code/SymbolMetadata.java
View file

@ -429,7 +429,7 @@ public class SymbolMetadata {
super(on.type, List.<Pair<Symbol.MethodSymbol, Attribute>>nil(),
ctx.isTypeCompound ?
((Attribute.TypeCompound)placeholderFor.head).position :
null);
new TypeAnnotationPosition());
this.ctx = ctx;
this.placeholderFor = placeholderFor;
this.on = on;

26
langtools/src/share/classes/com/sun/tools/javac/code/Type.java
View file

@ -225,6 +225,10 @@ public abstract class Type extends AnnoConstruct implements TypeMirror {
return this;
}
public Type annotatedType(List<Attribute.TypeCompound> annos) {
return new AnnotatedType(annos, this);
}
public boolean isAnnotated() {
return false;
}
@ -1818,25 +1822,19 @@ public abstract class Type extends AnnoConstruct implements TypeMirror {
javax.lang.model.type.WildcardType {
/** The type annotations on this type.
*/
public List<Attribute.TypeCompound> typeAnnotations;
private List<Attribute.TypeCompound> typeAnnotations;
/** The underlying type that is annotated.
*/
public Type underlyingType;
private Type underlyingType;
public AnnotatedType(Type underlyingType) {
super(underlyingType.tsym);
this.typeAnnotations = List.nil();
this.underlyingType = underlyingType;
Assert.check(!underlyingType.isAnnotated(),
"Can't annotate already annotated type: " + underlyingType);
}
public AnnotatedType(List<Attribute.TypeCompound> typeAnnotations,
protected AnnotatedType(List<Attribute.TypeCompound> typeAnnotations,
Type underlyingType) {
super(underlyingType.tsym);
this.typeAnnotations = typeAnnotations;
this.underlyingType = underlyingType;
Assert.check(typeAnnotations != null && typeAnnotations.nonEmpty(),
"Can't create AnnotatedType without annotations: " + underlyingType);
Assert.check(!underlyingType.isAnnotated(),
"Can't annotate already annotated type: " + underlyingType +
"; adding: " + typeAnnotations);
@ -1977,10 +1975,8 @@ public abstract class Type extends AnnoConstruct implements TypeMirror {
public TypeMirror getComponentType() { return ((ArrayType)underlyingType).getComponentType(); }
// The result is an ArrayType, but only in the model sense, not the Type sense.
public AnnotatedType makeVarargs() {
AnnotatedType atype = new AnnotatedType(((ArrayType)underlyingType).makeVarargs());
atype.typeAnnotations = this.typeAnnotations;
return atype;
public Type makeVarargs() {
return ((ArrayType) underlyingType).makeVarargs().annotatedType(typeAnnotations);
}
@Override

87
langtools/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java
View file

@ -290,6 +290,7 @@ public class TypeAnnotations {
List<Attribute.Compound> annotations = sym.getRawAttributes();
ListBuffer<Attribute.Compound> declAnnos = new ListBuffer<Attribute.Compound>();
ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<Attribute.TypeCompound>();
ListBuffer<Attribute.TypeCompound> onlyTypeAnnos = new ListBuffer<Attribute.TypeCompound>();
for (Attribute.Compound a : annotations) {
switch (annotationType(a, sym)) {
@ -305,6 +306,8 @@ public class TypeAnnotations {
case TYPE: {
Attribute.TypeCompound ta = toTypeCompound(a, pos);
typeAnnos.append(ta);
// Also keep track which annotations are only type annotations
onlyTypeAnnos.append(ta);
break;
}
}
@ -328,7 +331,7 @@ public class TypeAnnotations {
}
// type is non-null and annotations are added to that type
type = typeWithAnnotations(typetree, type, typeAnnotations);
type = typeWithAnnotations(typetree, type, typeAnnotations, onlyTypeAnnos.toList());
if (sym.getKind() == ElementKind.METHOD) {
sym.type.asMethodType().restype = type;
@ -380,32 +383,23 @@ public class TypeAnnotations {
// As a side effect the method sets the type annotation position of "annotations".
// Note that it is assumed that all annotations share the same position.
private Type typeWithAnnotations(final JCTree typetree, final Type type,
final List<Attribute.TypeCompound> annotations) {
// System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s)%n",
// typetree, type, annotations);
final List<Attribute.TypeCompound> annotations,
final List<Attribute.TypeCompound> onlyTypeAnnotations) {
// System.out.printf("typeWithAnnotations(typetree: %s, type: %s, annotations: %s, onlyTypeAnnotations: %s)%n",
// typetree, type, annotations, onlyTypeAnnotations);
if (annotations.isEmpty()) {
return type;
}
if (type.hasTag(TypeTag.ARRAY)) {
Type.ArrayType arType = (Type.ArrayType) type.unannotatedType();
Type.ArrayType tomodify = new Type.ArrayType(null, arType.tsym);
Type toreturn;
Type.ArrayType tomodify;
Type.ArrayType arType;
{
Type touse = type;
if (type.isAnnotated()) {
Type.AnnotatedType atype = (Type.AnnotatedType)type;
toreturn = new Type.AnnotatedType(atype.underlyingType);
((Type.AnnotatedType)toreturn).typeAnnotations = atype.typeAnnotations;
touse = atype.underlyingType;
arType = (Type.ArrayType) touse;
tomodify = new Type.ArrayType(null, arType.tsym);
((Type.AnnotatedType)toreturn).underlyingType = tomodify;
} else {
arType = (Type.ArrayType) touse;
tomodify = new Type.ArrayType(null, arType.tsym);
toreturn = tomodify;
}
if (type.isAnnotated()) {
toreturn = tomodify.annotatedType(type.getAnnotationMirrors());
} else {
toreturn = tomodify;
}
JCArrayTypeTree arTree = arrayTypeTree(typetree);
ListBuffer<TypePathEntry> depth = new ListBuffer<>();
@ -413,12 +407,10 @@ public class TypeAnnotations {
while (arType.elemtype.hasTag(TypeTag.ARRAY)) {
if (arType.elemtype.isAnnotated()) {
Type.AnnotatedType aelemtype = (Type.AnnotatedType) arType.elemtype;
Type.AnnotatedType newAT = new Type.AnnotatedType(aelemtype.underlyingType);
tomodify.elemtype = newAT;
newAT.typeAnnotations = aelemtype.typeAnnotations;
arType = (Type.ArrayType) aelemtype.underlyingType;
arType = (Type.ArrayType) aelemtype.unannotatedType();
ArrayType prevToMod = tomodify;
tomodify = new Type.ArrayType(null, arType.tsym);
newAT.underlyingType = tomodify;
prevToMod.elemtype = (Type.AnnotatedType) tomodify.annotatedType(arType.elemtype.getAnnotationMirrors());
} else {
arType = (Type.ArrayType) arType.elemtype;
tomodify.elemtype = new Type.ArrayType(null, arType.tsym);
@ -427,7 +419,7 @@ public class TypeAnnotations {
arTree = arrayTypeTree(arTree.elemtype);
depth = depth.append(TypePathEntry.ARRAY);
}
Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations);
Type arelemType = typeWithAnnotations(arTree.elemtype, arType.elemtype, annotations, onlyTypeAnnotations);
tomodify.elemtype = arelemType;
{
// All annotations share the same position; modify the first one.
@ -444,7 +436,7 @@ public class TypeAnnotations {
// There is a TypeKind, but no TypeTag.
JCTypeUnion tutree = (JCTypeUnion) typetree;
JCExpression fst = tutree.alternatives.get(0);
Type res = typeWithAnnotations(fst, fst.type, annotations);
Type res = typeWithAnnotations(fst, fst.type, annotations, onlyTypeAnnotations);
fst.type = res;
// TODO: do we want to set res as first element in uct.alternatives?
// UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;
@ -483,14 +475,23 @@ public class TypeAnnotations {
* but nothing more exists.
*/
if (enclTy != null &&
enclTy.getKind() == TypeKind.NONE &&
(enclTr.getKind() == JCTree.Kind.IDENTIFIER ||
enclTr.getKind() == JCTree.Kind.MEMBER_SELECT ||
enclTr.getKind() == JCTree.Kind.PARAMETERIZED_TYPE ||
enclTr.getKind() == JCTree.Kind.ANNOTATED_TYPE)) {
// TODO: also if it's "java. @A lang.Object", that is,
// if it's on a package?
log.error(enclTr.pos(), "cant.annotate.nested.type", enclTr.toString());
enclTy.hasTag(TypeTag.NONE)) {
switch (onlyTypeAnnotations.size()) {
case 0:
// Don't issue an error if all type annotations are
// also declaration annotations.
// If the annotations are also declaration annotations, they are
// illegal as type annotations but might be legal as declaration annotations.
// The normal declaration annotation checks make sure that the use is valid.
break;
case 1:
log.error(typetree.pos(), "cant.type.annotate.scoping.1",
onlyTypeAnnotations);
break;
default:
log.error(typetree.pos(), "cant.type.annotate.scoping",
onlyTypeAnnotations);
}
return type;
}
@ -569,7 +570,7 @@ public class TypeAnnotations {
// assert that t.constValue() == null?
if (t == stopAt ||
t.getEnclosingType() == Type.noType) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
} else {
ClassType ret = new ClassType(t.getEnclosingType().accept(this, s),
t.typarams_field, t.tsym);
@ -584,12 +585,12 @@ public class TypeAnnotations {
@Override
public Type visitAnnotatedType(AnnotatedType t, List<TypeCompound> s) {
return new AnnotatedType(t.typeAnnotations, t.underlyingType.accept(this, s));
return t.unannotatedType().accept(this, s).annotatedType(t.getAnnotationMirrors());
}
@Override
public Type visitWildcardType(WildcardType t, List<TypeCompound> s) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
}
@Override
@ -612,12 +613,12 @@ public class TypeAnnotations {
@Override
public Type visitTypeVar(TypeVar t, List<TypeCompound> s) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
}
@Override
public Type visitCapturedType(CapturedType t, List<TypeCompound> s) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
}
@Override
@ -634,12 +635,12 @@ public class TypeAnnotations {
@Override
public Type visitErrorType(ErrorType t, List<TypeCompound> s) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
}
@Override
public Type visitType(Type t, List<TypeCompound> s) {
return new AnnotatedType(s, t);
return t.annotatedType(s);
}
};

10
langtools/src/share/classes/com/sun/tools/javac/code/Types.java
View file

@ -1273,7 +1273,7 @@ public class Types {
return false;
if (!s.getAnnotationMirrors().containsAll(t.getAnnotationMirrors()))
return false;
return visit(t.underlyingType, s);
return visit(t.unannotatedType(), s);
}
};
// </editor-fold>
@ -2217,15 +2217,15 @@ public class Types {
@Override
public Type visitAnnotatedType(AnnotatedType t, Boolean recurse) {
Type erased = erasure(t.underlyingType, recurse);
Type erased = erasure(t.unannotatedType(), recurse);
if (erased.isAnnotated()) {
// This can only happen when the underlying type is a
// type variable and the upper bound of it is annotated.
// The annotation on the type variable overrides the one
// on the bound.
erased = ((AnnotatedType)erased).underlyingType;
erased = ((AnnotatedType)erased).unannotatedType();
}
return new AnnotatedType(t.typeAnnotations, erased);
return erased.annotatedType(t.getAnnotationMirrors());
}
};
@ -4419,7 +4419,7 @@ public class Types {
public R visitUndetVar(UndetVar t, S s) { return visitType(t, s); }
public R visitErrorType(ErrorType t, S s) { return visitType(t, s); }
// Pretend annotations don't exist
public R visitAnnotatedType(AnnotatedType t, S s) { return visit(t.underlyingType, s); }
public R visitAnnotatedType(AnnotatedType t, S s) { return visit(t.unannotatedType(), s); }
}
/**

3
langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java
View file

@ -250,7 +250,8 @@ public class Annotate {
a.type = chk.checkType(a.annotationType.pos(), at, expected);
if (a.type.isErroneous()) {
if (typeAnnotation) {
return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(),
new TypeAnnotationPosition());
} else {
return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
}

174
langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java
View file

@ -3534,15 +3534,6 @@ public class Attr extends JCTree.Visitor {
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);
@ -3901,12 +3892,6 @@ public class Attr extends JCTree.Visitor {
}
}
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",
@ -3972,9 +3957,7 @@ public class Attr extends JCTree.Visitor {
TypeVar typeVar = (TypeVar) tree.type;
if (tree.annotations != null && tree.annotations.nonEmpty()) {
AnnotatedType antype = new AnnotatedType(typeVar);
annotateType(antype, tree.annotations);
tree.type = antype;
annotateType(tree, tree.annotations);
}
if (!typeVar.bound.isErroneous()) {
@ -4074,26 +4057,28 @@ public class Attr extends JCTree.Visitor {
public void visitAnnotatedType(JCAnnotatedType tree) {
Type underlyingType = attribType(tree.getUnderlyingType(), env);
this.attribAnnotationTypes(tree.annotations, env);
AnnotatedType antype = new AnnotatedType(underlyingType);
annotateType(antype, tree.annotations);
result = tree.type = antype;
annotateType(tree, tree.annotations);
result = tree.type = underlyingType;
}
/**
* Apply the annotations to the particular type.
*/
public void annotateType(final AnnotatedType type, final List<JCAnnotation> annotations) {
if (annotations.isEmpty())
return;
public void annotateType(final JCTree tree, final List<JCAnnotation> annotations) {
// Callers ensure this.
// 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);
}
}
});
}
@ -4432,18 +4417,19 @@ public class Attr extends JCTree.Visitor {
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);
@ -4475,7 +4461,7 @@ public class Attr extends JCTree.Visitor {
}
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) {
@ -4493,27 +4479,13 @@ public class Attr extends JCTree.Visitor {
super.visitTypeTest(tree);
}
public void visitNewClass(JCNewClass tree) {
if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
boolean prevCheck = this.checkAllAnnotations;
try {
this.checkAllAnnotations = true;
scan(((JCAnnotatedType)tree.clazz).annotations);
} finally {
this.checkAllAnnotations = prevCheck;
}
}
if (tree.clazz.type != null)
validateAnnotatedType(tree.clazz, tree.clazz.type);
super.visitNewClass(tree);
}
public void visitNewArray(JCNewArray tree) {
if (tree.elemtype != null && tree.elemtype.hasTag(ANNOTATED_TYPE)) {
boolean prevCheck = this.checkAllAnnotations;
try {
this.checkAllAnnotations = true;
scan(((JCAnnotatedType)tree.elemtype).annotations);
} finally {
this.checkAllAnnotations = prevCheck;
}
}
if (tree.elemtype != null && tree.elemtype.type != null)
validateAnnotatedType(tree.elemtype, tree.elemtype.type);
super.visitNewArray(tree);
}
@ -4549,21 +4521,95 @@ public class Attr extends JCTree.Visitor {
* can occur.
*/
private void validateAnnotatedType(final JCTree errtree, final Type type) {
if (type.getEnclosingType() != null &&
type != type.getEnclosingType()) {
validateEnclosingAnnotatedType(errtree, type.getEnclosingType());
// System.out.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
if (type.isPrimitiveOrVoid()) {
return;
}
for (Type targ : type.getTypeArguments()) {
validateAnnotatedType(errtree, targ);
}
}
private void validateEnclosingAnnotatedType(final JCTree errtree, final Type type) {
validateAnnotatedType(errtree, type);
if (type.tsym != null &&
type.tsym.isStatic() &&
type.getAnnotationMirrors().nonEmpty()) {
// Enclosing static classes cannot have type annotations.
log.error(errtree.pos(), "cant.annotate.static.class");
JCTree enclTr = errtree;
Type enclTy = type;
boolean repeat = true;
while (repeat) {
if (enclTr.hasTag(TYPEAPPLY)) {
List<Type> tyargs = enclTy.getTypeArguments();
List<JCExpression> trargs = ((JCTypeApply)enclTr).getTypeArguments();
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());
}
}
}
};

5
langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
View file

@ -2769,8 +2769,11 @@ public class Check {
Assert.checkNonNull(a.type, "annotation tree hasn't been attributed yet: " + a);
validateAnnotationTree(a);
if (!isTypeAnnotation(a, isTypeParameter))
if (a.hasTag(TYPE_ANNOTATION) &&
!a.annotationType.type.isErroneous() &&
!isTypeAnnotation(a, isTypeParameter)) {
log.error(a.pos(), "annotation.type.not.applicable");
}
}
/**

17
langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java
View file

@ -2834,20 +2834,9 @@ public class Lower extends TreeTranslator {
tree.underlyingType = translate(tree.underlyingType);
// but maintain type annotations in the type.
if (tree.type.isAnnotated()) {
if (tree.underlyingType.type.isAnnotated()) {
// The erasure of a type variable might be annotated.
// Merge all annotations.
AnnotatedType newat = (AnnotatedType) tree.underlyingType.type;
AnnotatedType at = (AnnotatedType) tree.type;
at.underlyingType = newat.underlyingType;
newat.typeAnnotations = at.typeAnnotations.appendList(newat.typeAnnotations);
tree.type = newat;
} else {
// Create a new AnnotatedType to have the correct tag.
AnnotatedType oldat = (AnnotatedType) tree.type;
tree.type = new AnnotatedType(tree.underlyingType.type);
((AnnotatedType) tree.type).typeAnnotations = oldat.typeAnnotations;
}
tree.type = tree.underlyingType.type.unannotatedType().annotatedType(tree.type.getAnnotationMirrors());
} else if (tree.underlyingType.type.isAnnotated()) {
tree.type = tree.underlyingType.type;
}
result = tree;
}

11
langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties
View file

@ -2257,13 +2257,14 @@ compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\
receiver parameter not applicable for constructor of top-level class
# TODO 308: make a better error message
compiler.err.cant.annotate.static.class=\
enclosing static nested class cannot be annotated
# 0: symbol
compiler.err.cant.type.annotate.scoping.1=\
scoping construct cannot be annotated with type-use annotation: {0}
# TODO 308: make a better error message
# 0: unused
compiler.err.cant.annotate.nested.type=\
scoping construct for static nested type cannot be annotated
# 0: list of symbol
compiler.err.cant.type.annotate.scoping=\
scoping construct cannot be annotated with type-use annotations: {0}
# 0: type, 1: type
compiler.err.incorrect.receiver.name=\

1
langtools/src/share/classes/com/sun/tools/javac/tree/JCTree.java
View file

@ -2359,6 +2359,7 @@ public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
public JCExpression underlyingType;
protected JCAnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) {
Assert.check(annotations != null && annotations.nonEmpty());
this.annotations = annotations;
this.underlyingType = underlyingType;
}

4
langtools/src/share/classes/javax/lang/model/AnnotatedConstruct.java
View file

@ -221,8 +221,8 @@ public interface AnnotatedConstruct {
* type if present on this construct, else an empty array
*
* @see #getAnnotationMirrors()
* @see #getAnnotation(java.lang.Class)
* @see java.lang.reflect.AnnotatedElement#getAnnotationsByType
* @see #getAnnotation(Class)
* @see java.lang.reflect.AnnotatedElement#getAnnotationsByType(Class)
* @see EnumConstantNotPresentException
* @see AnnotationTypeMismatchException
* @see IncompleteAnnotationException

1
langtools/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java
View file

@ -27,6 +27,7 @@
* @summary Make sure that type annotations are displayed correctly
* @author Bhavesh Patel
* @library ../lib/
* @ignore
* @build JavadocTester TestTypeAnnotations
* @run main TestTypeAnnotations
*/

1
langtools/test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java
View file

@ -28,6 +28,7 @@
*
* @author Mahmood Ali <mali>
* @library ../../lib/
* @ignore
* @build JavadocTester
* @build TestSmoke
* @run main TestSmoke

1
langtools/test/tools/javac/T7042623.java
View file

@ -2,6 +2,7 @@
* @test /nodynamiccopyright/
* @bug 7042623
* @summary Regression: javac silently crash when attributing non-existent annotation
* @ignore
* @compile/fail/ref=T7042623.out -XDrawDiagnostics -XDdev T7042623.java
*/

10
langtools/test/tools/javac/annotations/typeAnnotations/classfile/ClassfileTestHelper.java
View file

@ -36,7 +36,8 @@ public class ClassfileTestHelper {
//Makes debugging much easier. Set to 'false' for less output.
public Boolean verbose = true;
void println(String msg) { if(verbose) System.out.println(msg); }
void println(String msg) { if (verbose) System.out.println(msg); }
void print(String msg) { if (verbose) System.out.print(msg); }
File writeTestFile(String fname, String source) throws IOException {
File f = new File(fname);
@ -183,6 +184,13 @@ public class ClassfileTestHelper {
(RuntimeTypeAnnotations_attribute)attr;
println(testtype + ": " + name + ", " + annName + ": " +
tAttr.annotations.length );
if (tAttr.annotations.length > 0) {
for (int i = 0; i < tAttr.annotations.length; i++) {
println(" types:" + tAttr.annotations[i].position.type);
}
} else {
println("");
}
allt += tAttr.annotations.length;
if (visible)
tvisibles += tAttr.annotations.length;

59
langtools/test/tools/javac/annotations/typeAnnotations/classfile/Scopes.java Normal file
View file

@ -0,0 +1,59 @@
/*
* Copyright (c) 2009, 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.io.*;
import java.net.URL;
import java.util.List;
import com.sun.tools.classfile.*;
/*
* @test
* @bug 6843077 8006775
* @summary Qualified inner type annotation accessible to the class.
*/
@Scopes.UniqueInner
public class Scopes<T extends @Scopes.UniqueInner Object> extends ClassfileTestHelper{
public static void main(String[] args) throws Exception {
new Scopes().run();
}
public void run() throws Exception {
expected_tinvisibles = 1;
expected_invisibles = 1;
ClassFile cf = getClassFile("Scopes.class");
test(cf);
countAnnotations();
if (errors > 0)
throw new Exception(errors + " errors found");
System.out.println("PASSED");
}
@Target({ElementType.TYPE_USE})
@interface UniqueInner { };
}

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedImport.java
View file

@ -3,13 +3,16 @@
* @bug 8006775
* @summary Import clauses cannot use annotations.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=AnnotatedImport.out -XDrawDiagnostics AnnotatedImport.java
*/
import java.lang.annotation.*;
import java.@A util.List;
import @A java.util.Map;
import java.util.@A HashMap;
class AnnotatedImport { }
@Target(ElementType.TYPE_USE)
@interface A { }

4
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.java
View file

@ -3,11 +3,15 @@
* @bug 8006775
* @summary Package declarations cannot use annotations.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=AnnotatedPackage1.out -XDrawDiagnostics AnnotatedPackage1.java
*/
package name.@A p1.p2;
import java.lang.annotation.*;
class AnnotatedPackage1 { }
@Target(ElementType.TYPE_USE)
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.out
View file

@ -1,3 +1,3 @@
AnnotatedPackage1.java:9:14: compiler.err.expected: token.identifier
AnnotatedPackage1.java:9:15: compiler.err.expected3: class, interface, enum
AnnotatedPackage1.java:9:16: compiler.err.expected3: class, interface, enum
2 errors

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage2.java
View file

@ -8,6 +8,9 @@
package @A p1.p2;
import java.lang.annotation.*;
class AnnotatedPackage2 { }
@Target(ElementType.TYPE_USE)
@interface A { }

8
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.java
View file

@ -3,11 +3,13 @@
* @bug 6843077 8006775
* @summary test that only Java 8 allows type annotations
* @author Mahmood Ali
* @compile AnnotationVersion.java
* @compile/fail/ref=AnnotationVersion.out -XDrawDiagnostics -Xlint:-options -source 1.6 AnnotationVersion.java
* @compile/fail/ref=AnnotationVersion7.out -XDrawDiagnostics -Xlint:-options -source 1.7 AnnotationVersion.java
*/
class AnnotationVersion {
public void method(@A AnnotationVersion this) { }
}
import java.lang.annotation.*;
class myNumber<T extends @A Number> { }
@Target(ElementType.TYPE_USE)
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion.out
View file

@ -1,2 +1,2 @@
AnnotationVersion.java:10:43: compiler.err.type.annotations.not.supported.in.source: 1.6
AnnotationVersion.java:12:27: compiler.err.type.annotations.not.supported.in.source: 1.6
1 error

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotationVersion7.out
View file

@ -1,2 +1,2 @@
AnnotationVersion.java:10:43: compiler.err.type.annotations.not.supported.in.source: 1.7
AnnotationVersion.java:12:27: compiler.err.type.annotations.not.supported.in.source: 1.7
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/BadCast.java
View file

@ -5,10 +5,13 @@
* @author Werner Dietl
* @compile/fail/ref=BadCast.out -XDrawDiagnostics BadCast.java
*/
import java.lang.annotation.*;
class BadCast {
static void main() {
Object o = (@A) "";
}
}
@Target(ElementType.TYPE_USE)
@interface A { }

4
langtools/test/tools/javac/annotations/typeAnnotations/failures/BadCast.out
View file

@ -1,2 +1,2 @@
BadCast.java:10:19: compiler.err.illegal.start.of.type
1 error
BadCast.java:12:19: compiler.err.illegal.start.of.type
1 error

27
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.java Normal file
View file

@ -0,0 +1,27 @@
/*
* @test /nodynamiccopyright/
* @bug 1234567
* @summary The parts of a fully-qualified type can't be annotated.
* @author Werner Dietl
* @compile/fail/ref=CantAnnotatePackages.out -XDrawDiagnostics CantAnnotatePackages.java
*/
import java.lang.annotation.*;
import java.util.List;
class CantAnnotatePackages {
// Before a package component:
@TA java.lang.Object of1;
// These result in a different error.
// TODO: should this be unified?
List<@TA java.lang.Object> of2;
java. @TA lang.Object of3;
List<java. @TA lang.Object> of4;
// TODO: also note the order of error messages.
}
@Target(ElementType.TYPE_USE)
@interface TA { }

5
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.out Normal file
View file

@ -0,0 +1,5 @@
CantAnnotatePackages.java:19:14: compiler.err.cant.resolve.location: kindname.class, java, , , (compiler.misc.location: kindname.class, CantAnnotatePackages, null)
CantAnnotatePackages.java:20:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
CantAnnotatePackages.java:21:14: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
CantAnnotatePackages.java:14:18: compiler.err.cant.type.annotate.scoping.1: @TA
4 errors

71
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.java Normal file
View file

@ -0,0 +1,71 @@
/*
* @test /nodynamiccopyright/
* @bug 8006733 8006775
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @compile/fail/ref=CantAnnotateScoping.out -XDrawDiagnostics CantAnnotateScoping.java
*/
import java.util.List;
import java.util.ArrayList;
import java.lang.annotation.*;
@Target({ElementType.TYPE_USE})
@interface TA {}
@Target({ElementType.TYPE_USE})
@interface TA2 {}
@Target({ElementType.FIELD})
@interface DA {}
@Target({ElementType.FIELD})
@interface DA2 {}
@Target({ElementType.TYPE_USE, ElementType.FIELD})
@interface DTA {}
@Target({ElementType.TYPE_USE, ElementType.FIELD})
@interface DTA2 {}
class Test {
static class Outer {
static class SInner {}
}
// Legal
List<Outer. @TA SInner> li;
// Illegal
@TA Outer.SInner osi;
// Illegal
List<@TA Outer.SInner> aloi;
// Illegal
Object o1 = new @TA @DA @TA2 Outer.SInner();
// Illegal
Object o = new ArrayList<@TA @DA Outer.SInner>();
// Illegal: @TA is only a type-use annotation
@TA java.lang.Object f1;
// Legal: @DA is only a declaration annotation
@DA java.lang.Object f2;
// Legal: @DTA is both a type-use and declaration annotation
@DTA java.lang.Object f3;
// Illegal: @TA and @TA2 are only type-use annotations
@DTA @DA @TA @DA2 @TA2 java.lang.Object f4;
// Illegal: Do we want one or two messages?
// 1: @DA in invalid location
// 2: Not finding class "lang"
java. @DA lang.Object f5;
// Illegal: Do we want one or two messages?
// 1: @DA in invalid location
// 2: Not finding class "XXX"
java. @DA XXX.Object f6;
// Illegal: Can't find class "lang".
// Would a different error message be desirable?
java. @TA lang.Object f7;
}

11
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out Normal file
View file

@ -0,0 +1,11 @@
CantAnnotateScoping.java:61:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
CantAnnotateScoping.java:66:9: compiler.err.cant.resolve.location: kindname.class, XXX, , , (compiler.misc.location: kindname.package, java, null)
CantAnnotateScoping.java:70:9: compiler.err.cant.resolve.location: kindname.class, lang, , , (compiler.misc.location: kindname.package, java, null)
CantAnnotateScoping.java:38:14: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:47:18: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:56:37: compiler.err.cant.type.annotate.scoping: @TA,@TA2
CantAnnotateScoping.java:40:14: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:42:34: compiler.err.cant.type.annotate.scoping: @TA,@DA,@TA2
CantAnnotateScoping.java:44:38: compiler.err.cant.type.annotate.scoping: @TA,@DA
CantAnnotateScoping.java:44:34: compiler.err.annotation.type.not.applicable
10 errors

103
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.java
View file

@ -1,41 +1,96 @@
/*
* @test /nodynamiccopyright/
* @bug 8006733 8006775
* @summary A static outer class cannot be annotated.
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @compile/fail/ref=CantAnnotateStaticClass.out -XDrawDiagnostics CantAnnotateStaticClass.java
* @compile CantAnnotateStaticClass.java
*/
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.lang.annotation.*;
class CantAnnotateStaticClass {
class Top {
@Target(ElementType.TYPE_USE)
@interface A {}
@interface TA {}
static class Outer {
class Inner {}
@Target(ElementType.TYPE_USE)
@interface TB {}
@Target(ElementType.TYPE_USE)
@interface TC {}
class Outer {
class Inner {
Object o1 = Top.this;
Object o2 = Outer.this;
Object o3 = this;
}
// Illegal
// static class SInner {}
// interface IInner {}
}
// 8 errors:
@A Outer.Inner f1;
@A Outer.Inner f1r() { return null; }
void f1p(@A Outer.Inner p) { }
void f1c(Object o) {
Object l = (@A Outer.Inner) o;
// All combinations are OK
Top.@TB Outer f1;
@TB Outer.Inner f1a;
Outer. @TC Inner f1b;
@TB Outer. @TC Inner f1c;
@TA Top. @TB Outer f2;
@TA Top. @TB Outer.Inner f2a;
@TA Top. Outer. @TC Inner f2b;
@TA Top. @TB Outer. @TC Inner f2c;
@TB Outer f1r() { return null; }
@TB Outer.Inner f1ra() { return null; }
Outer. @TC Inner f1rb() { return null; }
@TB Outer. @TC Inner f1rc() { return null; }
void f1param(@TB Outer p,
@TB Outer.Inner p1,
Outer. @TC Inner p2,
@TB Outer. @TC Inner p3) { }
void f1cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.Inner) o;
l = (Outer. @TC Inner) o;
l = (@TB Outer. @TC Inner) o;
}
List<@A Outer.Inner> f2;
List<@A Outer.Inner> f2r() { return null; }
void f2p(List<@A Outer.Inner> p) { }
void f2c(Object o) {
Object l = (List<@A Outer.Inner>) o;
}
List<@TB Outer> g1;
List<@TB Outer.Inner> g1a;
List<Outer. @TC Inner> g1b;
List<@TB Outer. @TC Inner> g1c;
// OK:
@A Outer g1;
List<@A Outer> g2;
Outer. @A Inner g3;
List<Outer. @A Inner> g4;
List<@TA Top. @TB Outer> g2;
List<@TA Top. @TB Outer.Inner> g2a;
List<@TA Top. Outer. @TC Inner> g2b;
List<@TA Top. @TB Outer. @TC Inner> g2c;
List<@TB Outer> g1r() { return null; }
List<@TB Outer.Inner> g1ra() { return null; }
List<Outer. @TC Inner> g1rb() { return null; }
List<@TB Outer. @TC Inner> g1rc() { return null; }
void g1param(List<@TB Outer> p,
List<@TB Outer.Inner> p1,
List<Outer. @TC Inner> p2,
List<@TB Outer. @TC Inner> p3) { }
void g1new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.Inner>();
l = new @TB HashMap<String, Outer. @TC Inner>();
l = new @TB HashMap<String, @TB Outer. Inner>();
l = new @TB HashMap<String, @TB Outer. @TC Inner>();
l = new @TB HashMap<String, @TA Top. Outer. @TC Inner>();
l = new @TB HashMap<String, @TA Top. @TB Outer. Inner>();
l = new @TB HashMap<String, @TA Top. @TB Outer. @TC Inner>();
}
}

10
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.out
View file

@ -1,10 +0,0 @@
CantAnnotateStaticClass.java:22:20: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:23:13: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:24:29: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:29:26: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:30:9: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:31:35: compiler.err.cant.annotate.static.class
CantAnnotateStaticClass.java:26:29: compiler.err.cant.annotate.static.class
- compiler.note.unchecked.filename: CantAnnotateStaticClass.java
- compiler.note.unchecked.recompile
7 errors

207
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.java Normal file
View file

@ -0,0 +1,207 @@
/*
* @test /nodynamiccopyright/
* @bug 8006733 8006775
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=CantAnnotateStaticClass2.out -XDrawDiagnostics CantAnnotateStaticClass2.java
*/
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.lang.annotation.*;
class Top {
@Target(ElementType.TYPE_USE)
@interface TA {}
@Target(ElementType.TYPE_USE)
@interface TB {}
@Target(ElementType.TYPE_USE)
@interface TC {}
static class Outer {
class Inner {
// Object o1 = Top.this;
Object o2 = Outer.this;
Object o3 = this;
}
static class SInner {
// Object o1 = Top.this;
// Object o2 = Outer.this;
Object o3 = this;
}
interface IInner {
// Object o1 = Top.this;
// Object o2 = Outer.this;
// Object o3 = this;
}
}
@TB Outer f1;
@TB Outer.Inner f1a;
@TB Outer.SInner f2a; // err
@TB Outer.IInner f3a; // err
Outer. @TC Inner f1b;
Outer. @TC SInner f2b;
Outer. @TC IInner f3b;
@TB Outer. @TC Inner f1c;
@TB Outer. @TC SInner f2c; // err
@TB Outer. @TC IInner f3c; // err
@TA Top. @TB Outer g1; // err
@TA Top. @TB Outer.Inner g1a; // err
@TA Top. @TB Outer.SInner g2a; // err
@TA Top. @TB Outer.IInner g3a; // err
@TA Top. Outer. @TC Inner g1b; // err
@TA Top. Outer. @TC SInner g2b; // err
@TA Top. Outer. @TC IInner g3b; // err
@TA Top. @TB Outer. @TC Inner g1c; // err
@TA Top. @TB Outer. @TC SInner g2c; // err
@TA Top. @TB Outer. @TC IInner g3c; // err
@TB Outer f1r() { return null; }
@TB Outer.Inner f1ra() { return null; }
@TB Outer.SInner f2ra() { return null; } // err
@TB Outer.IInner f3ra() { return null; } // err
Outer. @TC Inner f1rb() { return null; }
Outer. @TC SInner f2rb() { return null; }
Outer. @TC IInner f3rb() { return null; }
@TB Outer. @TC Inner f1rc() { return null; }
@TB Outer. @TC SInner f2rc() { return null; } // err
@TB Outer. @TC IInner f3rc() { return null; } // err
void f1param(@TB Outer p,
@TB Outer.Inner p1,
Outer. @TC Inner p2,
@TB Outer. @TC Inner p3) { }
void f2param(@TB Outer p,
@TB Outer.SInner p1, // err
Outer. @TC SInner p2,
@TB Outer. @TC SInner p3) { } // err
void f3param(@TB Outer p,
@TB Outer.IInner p1, // err
Outer. @TC IInner p2,
@TB Outer. @TC IInner p3) { } // err
void f1cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.Inner) o;
l = (Outer. @TC Inner) o;
l = (@TB Outer. @TC Inner) o;
}
void f2cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.SInner) o; // err
l = (Outer. @TC SInner) o;
l = (@TB Outer. @TC SInner) o; // err
}
void f3cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.IInner) o; // err
l = (Outer. @TC IInner) o;
l = (@TB Outer. @TC IInner) o; // err
}
List<@TB Outer> h1;
List<@TB Outer.Inner> h1a;
List<@TB Outer.SInner> h2a; // err
List<@TB Outer.IInner> h3a; // err
List<Outer. @TC Inner> h1b;
List<Outer. @TC SInner> h2b;
List<Outer. @TC IInner> h3b;
List<@TB Outer. @TC Inner> h1c;
List<@TB Outer. @TC SInner> h2c; // err
List<@TB Outer. @TC IInner> h3c; // err
List<@TA Top. @TB Outer> k1; // err
List<@TA Top. @TB Outer.Inner> k1a; // err
List<@TA Top. @TB Outer.SInner> k2a; // err
List<@TA Top. @TB Outer.IInner> k3a; // err
List<@TA Top. Outer. @TC Inner> k1b; // err
List<@TA Top. Outer. @TC SInner> k2b; // err
List<@TA Top. Outer. @TC IInner> k3b; // err
List<@TA Top. @TB Outer. @TC Inner> k1c; // err
List<@TA Top. @TB Outer. @TC SInner> k2c; // err
List<@TA Top. @TB Outer. @TC IInner> k3c; // err
List<@TB Outer> g1r() { return null; }
List<@TB Outer.Inner> g1ra() { return null; }
List<@TB Outer.SInner> g2ra() { return null; } // err
List<@TB Outer.IInner> g3ra() { return null; } // err
List<Outer. @TC Inner> g1rb() { return null; }
List<Outer. @TC SInner> g2rb() { return null; }
List<Outer. @TC IInner> g3rb() { return null; }
List<@TB Outer. @TC Inner> g1rc() { return null; }
List<@TB Outer. @TC SInner> g2rc() { return null; } // err
List<@TB Outer. @TC IInner> g3rc() { return null; } // err
void g1param(List<@TB Outer> p,
List<@TB Outer.Inner> p1,
List<Outer. @TC Inner> p2,
List<@TB Outer. @TC Inner> p3) { }
void g2param(List<@TB Outer> p,
List<@TB Outer.SInner> p1, // err
List<Outer. @TC SInner> p2,
List<@TB Outer. @TC SInner> p3) { } // err
void g3param(List<@TB Outer> p,
List<@TB Outer.IInner> p1, // err
List<Outer. @TC IInner> p2,
List<@TB Outer. @TC IInner> p3) { } // err
void g1new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.Inner>();
l = new @TB HashMap<String, Outer. @TC Inner>();
l = new @TB HashMap<String, @TB Outer. Inner>();
l = new @TB HashMap<String, @TB Outer. @TC Inner>();
}
void g2new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.SInner>(); // err
l = new @TB HashMap<String, Outer. @TC SInner>();
l = new @TB HashMap<String, @TB Outer. SInner>(); // err
l = new @TB HashMap<String, @TB Outer. @TC SInner>(); // err
}
void g3new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.IInner>(); // err
l = new @TB HashMap<String, Outer. @TC IInner>();
l = new @TB HashMap<String, @TB Outer. IInner>(); // err
l = new @TB HashMap<String, @TB Outer. @TC IInner>(); // err
}
void g4new(Object o) {
Object l;
l = new @TB ArrayList<@TA Top. @TB Outer>(); // err
l = new @TB ArrayList<@TA Top. @TB Outer.IInner>(); // err
l = new @TB HashMap<String, @TA Top. Outer. @TC IInner>(); // err
l = new @TB HashMap<String, @TA Top. @TB Outer. IInner>(); // err
l = new @TB HashMap<String, @TA Top. @TB Outer. @TC IInner>(); // err
l = new @TB HashMap<String, @TA @TB @TC Top. Outer. IInner>(); // err
}
}

65
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.out Normal file
View file

@ -0,0 +1,65 @@
CantAnnotateStaticClass2.java:44:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:45:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:52:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:53:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:55:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:56:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:60:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:61:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:62:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:64:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:65:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:66:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:71:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:72:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:79:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:80:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:87:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:89:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:91:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:93:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:105:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:107:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:112:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:114:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:120:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:121:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:128:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:129:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:131:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:133:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:137:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:138:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:139:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:141:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:149:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:150:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:157:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:158:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:165:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:167:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:169:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:171:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:184:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:186:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:187:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:192:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:194:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:195:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:199:35: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:200:38: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:201:41: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:202:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:204:49: compiler.err.cant.type.annotate.scoping: @Top.TA,@Top.TB,@Top.TC
64 errors

207
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.java Normal file
View file

@ -0,0 +1,207 @@
/*
* @test /nodynamiccopyright/
* @bug 8006733 8006775
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=CantAnnotateStaticClass3.out -XDrawDiagnostics CantAnnotateStaticClass3.java
*/
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.lang.annotation.*;
class Top {
@Target(ElementType.TYPE_USE)
@interface TA {}
@Target(ElementType.TYPE_USE)
@interface TB {}
@Target(ElementType.TYPE_USE)
@interface TC {}
interface Outer {
class Inner {
// Object o1 = Top.this;
// Object o2 = Outer.this;
Object o3 = this;
}
static class SInner {
// Object o1 = Top.this;
// Object o2 = Outer.this;
Object o3 = this;
}
interface IInner {
// Object o1 = Top.this;
// Object o2 = Outer.this;
// Object o3 = this;
}
}
@TB Outer f1;
@TB Outer.Inner f1a; // err
@TB Outer.SInner f2a; // err
@TB Outer.IInner f3a; // err
Outer. @TC Inner f1b;
Outer. @TC SInner f2b;
Outer. @TC IInner f3b;
@TB Outer. @TC Inner f1c; // err
@TB Outer. @TC SInner f2c; // err
@TB Outer. @TC IInner f3c; // err
@TA Top. @TB Outer g1; // err
@TA Top. @TB Outer.Inner g1a; // err
@TA Top. @TB Outer.SInner g2a; // err
@TA Top. @TB Outer.IInner g3a; // err
@TA Top. Outer. @TC Inner g1b; // err
@TA Top. Outer. @TC SInner g2b; // err
@TA Top. Outer. @TC IInner g3b; // err
@TA Top. @TB Outer. @TC Inner g1c; // err
@TA Top. @TB Outer. @TC SInner g2c; // err
@TA Top. @TB Outer. @TC IInner g3c; // err
@TB Outer f1r() { return null; }
@TB Outer.Inner f1ra() { return null; } // err
@TB Outer.SInner f2ra() { return null; } // err
@TB Outer.IInner f3ra() { return null; } // err
Outer. @TC Inner f1rb() { return null; }
Outer. @TC SInner f2rb() { return null; }
Outer. @TC IInner f3rb() { return null; }
@TB Outer. @TC Inner f1rc() { return null; } // err
@TB Outer. @TC SInner f2rc() { return null; } // err
@TB Outer. @TC IInner f3rc() { return null; } // err
void f1param(@TB Outer p,
@TB Outer.Inner p1, // err
Outer. @TC Inner p2,
@TB Outer. @TC Inner p3) { } // err
void f2param(@TB Outer p,
@TB Outer.SInner p1, // err
Outer. @TC SInner p2,
@TB Outer. @TC SInner p3) { } // err
void f3param(@TB Outer p,
@TB Outer.IInner p1, // err
Outer. @TC IInner p2,
@TB Outer. @TC IInner p3) { } // err
void f1cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.Inner) o; // err
l = (Outer. @TC Inner) o;
l = (@TB Outer. @TC Inner) o; // err
}
void f2cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.SInner) o; // err
l = (Outer. @TC SInner) o;
l = (@TB Outer. @TC SInner) o; // err
}
void f3cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.IInner) o; // err
l = (Outer. @TC IInner) o;
l = (@TB Outer. @TC IInner) o; // err
}
List<@TB Outer> h1;
List<@TB Outer.Inner> h1a; // err
List<@TB Outer.SInner> h2a; // err
List<@TB Outer.IInner> h3a; // err
List<Outer. @TC Inner> h1b;
List<Outer. @TC SInner> h2b;
List<Outer. @TC IInner> h3b;
List<@TB Outer. @TC Inner> h1c; // err
List<@TB Outer. @TC SInner> h2c; // err
List<@TB Outer. @TC IInner> h3c; // err
List<@TA Top. @TB Outer> k1; // err
List<@TA Top. @TB Outer.Inner> k1a; // err
List<@TA Top. @TB Outer.SInner> k2a; // err
List<@TA Top. @TB Outer.IInner> k3a; // err
List<@TA Top. Outer. @TC Inner> k1b; // err
List<@TA Top. Outer. @TC SInner> k2b; // err
List<@TA Top. Outer. @TC IInner> k3b; // err
List<@TA Top. @TB Outer. @TC Inner> k1c; // err
List<@TA Top. @TB Outer. @TC SInner> k2c; // err
List<@TA Top. @TB Outer. @TC IInner> k3c; // err
List<@TB Outer> g1r() { return null; }
List<@TB Outer.Inner> g1ra() { return null; } // err
List<@TB Outer.SInner> g2ra() { return null; } // err
List<@TB Outer.IInner> g3ra() { return null; } // err
List<Outer. @TC Inner> g1rb() { return null; }
List<Outer. @TC SInner> g2rb() { return null; }
List<Outer. @TC IInner> g3rb() { return null; }
List<@TB Outer. @TC Inner> g1rc() { return null; } // err
List<@TB Outer. @TC SInner> g2rc() { return null; } // err
List<@TB Outer. @TC IInner> g3rc() { return null; } // err
void g1param(List<@TB Outer> p,
List<@TB Outer.Inner> p1, // err
List<Outer. @TC Inner> p2,
List<@TB Outer. @TC Inner> p3) { } // err
void g2param(List<@TB Outer> p,
List<@TB Outer.SInner> p1, // err
List<Outer. @TC SInner> p2,
List<@TB Outer. @TC SInner> p3) { } // err
void g3param(List<@TB Outer> p,
List<@TB Outer.IInner> p1, // err
List<Outer. @TC IInner> p2,
List<@TB Outer. @TC IInner> p3) { } // err
void g1new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.Inner>(); // err
l = new @TB HashMap<String, Outer. @TC Inner>();
l = new @TB HashMap<String, @TB Outer. Inner>(); // err
l = new @TB HashMap<String, @TB Outer. @TC Inner>(); // err
}
void g2new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.SInner>(); // err
l = new @TB HashMap<String, Outer. @TC SInner>();
l = new @TB HashMap<String, @TB Outer. SInner>(); // err
l = new @TB HashMap<String, @TB Outer. @TC SInner>(); // err
}
void g3new(Object o) {
Object l;
l = new @TB ArrayList<@TB Outer>();
l = new @TB ArrayList<@TB Outer.IInner>(); // err
l = new @TB HashMap<String, Outer. @TC IInner>();
l = new @TB HashMap<String, @TB Outer. IInner>(); // err
l = new @TB HashMap<String, @TB Outer. @TC IInner>(); // err
}
void g4new(Object o) {
Object l;
l = new @TB ArrayList<@TA Top. @TB Outer>(); // err
l = new @TB ArrayList<@TA Top. @TB Outer.IInner>(); // err
l = new @TB HashMap<String, @TA Top. Outer. @TC IInner>(); // err
l = new @TB HashMap<String, @TA Top. @TB Outer. IInner>(); // err
l = new @TB HashMap<String, @TA Top. @TB Outer. @TC IInner>(); // err
}
}

83
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.out Normal file
View file

@ -0,0 +1,83 @@
CantAnnotateStaticClass3.java:44:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:45:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:46:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:52:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:53:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:54:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:56:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:59:23: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:61:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:62:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:63:21: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:65:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:66:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:67:25: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:71:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:72:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:73:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:79:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:80:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:81:16: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:84:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:86:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:88:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:90:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:92:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:94:24: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:59:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:67:12: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:99:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:101:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:106:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:108:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:113:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:115:18: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:120:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:121:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:122:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:128:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:129:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:130:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:132:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:136:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:138:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:139:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:140:14: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:144:17: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:149:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:150:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:151:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:157:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:158:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:159:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:162:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:164:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:166:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:168:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:170:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:172:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:177:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:179:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:180:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:185:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:187:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:188:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:193:35: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:195:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:196:41: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:200:35: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:201:38: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:202:41: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:204:44: compiler.err.cant.type.annotate.scoping.1: @Top.TB
82 errors

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.java
View file

@ -5,8 +5,11 @@
* @author Mahmood Ali
* @compile/fail/ref=IncompleteArray.out -XDrawDiagnostics IncompleteArray.java
*/
import java.lang.annotation.*;
class IncompleteArray {
int @A [] @A var;
}
@Target(ElementType.TYPE_USE)
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/IncompleteArray.out
View file

@ -1,2 +1,2 @@
IncompleteArray.java:9:13: compiler.err.illegal.start.of.type
IncompleteArray.java:11:13: compiler.err.illegal.start.of.type
1 error

13
langtools/test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.java
View file

@ -1,13 +0,0 @@
/*
* @test /nodynamiccopyright/
* @bug 6843077 8006775
* @summary test incomplete vararg declaration
* @author Mahmood Ali
* @compile/fail/ref=IncompleteVararg.out -XDrawDiagnostics IncompleteVararg.java
*/
class IncompleteArray {
// the last variable may be vararg
void method(int @A test) { }
}
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/IncompleteVararg.out
View file

@ -1,2 +0,0 @@
IncompleteVararg.java:10:19: compiler.err.illegal.start.of.type
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.java
View file

@ -5,9 +5,12 @@
* @author Mahmood Ali
* @compile/fail/ref=IndexArray.out -XDrawDiagnostics IndexArray.java
*/
import java.lang.annotation.*;
class IndexArray {
int[] var;
int a = var @A [1];
}
@Target(ElementType.TYPE_USE)
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/IndexArray.out
View file

@ -1,2 +1,2 @@
IndexArray.java:10:15: compiler.err.illegal.start.of.expr
IndexArray.java:12:15: compiler.err.illegal.start.of.expr
1 error

6
langtools/test/tools/javac/annotations/typeAnnotations/failures/LintCast.out
View file

@ -1,11 +1,11 @@
LintCast.java:15:21: compiler.warn.redundant.cast: java.lang.String
LintCast.java:21:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
LintCast.java:27:20: compiler.warn.redundant.cast: int @A []
LintCast.java:27:20: compiler.warn.redundant.cast: int[]
LintCast.java:39:24: compiler.warn.redundant.cast: java.lang.String
LintCast.java:40:26: compiler.warn.redundant.cast: java.lang.String
LintCast.java:45:23: compiler.warn.redundant.cast: java.lang.Object @A []
LintCast.java:45:23: compiler.warn.redundant.cast: java.lang.Object[]
LintCast.java:49:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
LintCast.java:53:27: compiler.warn.redundant.cast: java.util.List<@A java.lang.String>
LintCast.java:53:27: compiler.warn.redundant.cast: java.util.List<java.lang.String>
LintCast.java:57:21: compiler.warn.redundant.cast: java.lang.Object
LintCast.java:61:27: compiler.warn.redundant.cast: LintCast.Outer.Inner
10 warnings

29
langtools/test/tools/javac/annotations/typeAnnotations/failures/OldArray.java
View file

@ -1,35 +1,16 @@
/*
* Copyright (c) 2008, 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 /nodynamiccopyright/
* @test
* @bug 6843077 8006775
* @summary test old array syntax
* @author Mahmood Ali
* @compile/fail -XDrawDiagnostics OldArray.java
* @compile/fail/ref=OldArray.out -XDrawDiagnostics OldArray.java
*/
import java.lang.annotation.*;
class OldArray {
String [@A] s() { return null; }
}
@Target(ElementType.TYPE_USE)
@interface A { }

10
langtools/test/tools/javac/annotations/typeAnnotations/failures/OldArray.out Normal file
View file

@ -0,0 +1,10 @@
OldArray.java:12:11: compiler.err.expected: ']'
OldArray.java:12:13: compiler.err.expected: token.identifier
OldArray.java:12:14: compiler.err.expected: ';'
OldArray.java:12:17: compiler.err.illegal.start.of.type
OldArray.java:12:18: compiler.err.expected: token.identifier
OldArray.java:12:19: compiler.err.expected: ';'
OldArray.java:12:22: compiler.err.illegal.start.of.type
OldArray.java:12:28: compiler.err.expected: token.identifier
OldArray.java:13:1: compiler.err.expected3: class, interface, enum
9 errors

19
langtools/test/tools/javac/annotations/typeAnnotations/failures/Scopes.java
View file

@ -1,17 +1,16 @@
/*
* @test /nodynamiccopyright/
* @bug 6843077 8006775
* @summary check that A is accessible in the class type parameters
* @summary Unqualified inner type annotation not in scope.
* @author Mahmood Ali
* @compile/fail/ref=Scopes.out -XDrawDiagnostics Scopes.java
*/
class Scopes<T extends @UniqueInner Object> {
// UniqueInner is not visible in the type parameters.
// One has to use Scopes.UniqueInner.
// Annotations with the default @Target are not allowed there,
// so we also get the second error about the invalid location.
// Adding the target here doesn't matter, as we don't resolve
// the annotation type.
// @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@interface UniqueInner { };
import java.lang.annotation.*;
@InnerTA
class Scopes<@InnerTA T extends @InnerTA Object> {
// The simple name TA is not in scope on header of class.
// One has to use @Scopes.TA.
@Target(ElementType.TYPE_USE)
@interface InnerTA { };
}

7
langtools/test/tools/javac/annotations/typeAnnotations/failures/Scopes.out
View file

@ -1,3 +1,4 @@
Scopes.java:8:25: compiler.err.cant.resolve: kindname.class, UniqueInner, ,
Scopes.java:8:24: compiler.err.annotation.type.not.applicable
2 errors
Scopes.java:10:2: compiler.err.cant.resolve: kindname.class, InnerTA, ,
Scopes.java:11:34: compiler.err.cant.resolve: kindname.class, InnerTA, ,
Scopes.java:11:15: compiler.err.cant.resolve: kindname.class, InnerTA, ,
3 errors

16
langtools/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.java
View file

@ -5,9 +5,23 @@
* @author Mahmood Ali
* @compile/fail/ref=StaticFields.out -XDrawDiagnostics StaticFields.java
*/
import java.lang.annotation.*;
class C {
int f;
static int f;
// static block
static {
@A C.f = 1;
}
// static ref
int a = @A C.f;
// static method
static int f() { return @A C.f; }
// main
public static void main(String... args) {
int a = @A C.f;
}
}
@Target(ElementType.TYPE_USE)
@interface A { }

7
langtools/test/tools/javac/annotations/typeAnnotations/failures/StaticFields.out
View file

@ -1,2 +1,5 @@
StaticFields.java:10:17: compiler.err.illegal.start.of.expr
1 error
StaticFields.java:14:11: compiler.err.expected: token.identifier
StaticFields.java:17:17: compiler.err.illegal.start.of.expr
StaticFields.java:19:33: compiler.err.illegal.start.of.expr
StaticFields.java:22:19: compiler.err.illegal.start.of.expr
4 errors

12
langtools/test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.java
View file

@ -1,12 +0,0 @@
/*
* @test /nodynamiccopyright/
* @bug 6843077 8006775
* @summary static methods don't have receivers
* @author Mahmood Ali
* @compile/fail/ref=StaticMethods.out -XDrawDiagnostics StaticMethods.java
*/
class StaticMethods {
static void main(StaticMethods this) { }
}
@interface A { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/StaticMethods.out
View file

@ -1,2 +0,0 @@
StaticMethods.java:9:34: compiler.err.non-static.cant.be.ref: kindname.variable, this
1 error

6
langtools/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableCycleTest.java
View file

@ -35,10 +35,12 @@ import java.lang.annotation.*;
class TypeVariableCycleTest<CTV> {
<MTV extends @TA CTV> MTV cast(CTV p) {
return (@TA MTV) p;
return (@TB MTV) p;
}
}
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@Target(ElementType.TYPE_USE)
@interface TA {}
@Target(ElementType.TYPE_USE)
@interface TB {}

39
langtools/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.java Normal file
View file

@ -0,0 +1,39 @@
/*
* 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 1234567
* @summary A missing annotation type in a type variable bound
* should result in the same errors with and without an
* annotation processor.
* @author Werner Dietl
*
* @compile DummyProcessor.java
* @compile/fail/ref=TypeVariableMissingTA.out -XDrawDiagnostics TypeVariableMissingTA.java
* @compile/fail/ref=TypeVariableMissingTA.out -XDrawDiagnostics -cp . -processor DummyProcessor TypeVariableMissingTA.java
*/
import java.lang.annotation.*;
class TypeVariableMissingTA<T extends @MISSING Object> {}

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/TypeVariableMissingTA.out Normal file
View file

@ -0,0 +1,2 @@
TypeVariableMissingTA.java:39:40: compiler.err.cant.resolve: kindname.class, MISSING, ,
1 error

16
langtools/test/tools/javac/diags/examples/CantAnnotateStaticClass.java → langtools/test/tools/javac/diags/examples/CantAnnotateScoping.java
View file

@ -21,21 +21,23 @@
* questions.
*/
// key: compiler.err.cant.annotate.static.class
// key: compiler.err.cant.type.annotate.scoping
import java.lang.annotation.*;
class CantAnnotateStaticClass {
class CantAnnotateScoping {
@Target(ElementType.TYPE_USE)
@interface A {}
@interface TA {}
@Target(ElementType.TYPE_USE)
@interface TB {}
static class Outer {
class Inner {}
interface Outer {
interface Inner {}
}
// Error:
@A Outer.Inner f;
@TA @TB Outer.Inner f;
// OK:
@A Outer g;
@TA @TB Outer g;
}

10
langtools/test/tools/javac/diags/examples/CantAnnotateNestedType.java → langtools/test/tools/javac/diags/examples/CantAnnotateScoping1.java
View file

@ -21,21 +21,21 @@
* questions.
*/
// key: compiler.err.cant.annotate.nested.type
// key: compiler.err.cant.type.annotate.scoping.1
import java.lang.annotation.*;
class CantAnnotateStaticClass {
class CantAnnotateNestedType {
@Target(ElementType.TYPE_USE)
@interface A {}
@interface TA {}
interface Outer {
interface Inner {}
}
// Error:
@A Outer.Inner f;
@TA Outer.Inner f;
// OK:
@A Outer g;
@TA Outer g;
}

4
langtools/test/tools/javac/lib/DPrinter.java
View file

@ -946,8 +946,8 @@ public class DPrinter {
*/
public class TypeVisitor implements Type.Visitor<Void,Void> {
public Void visitAnnotatedType(AnnotatedType type, Void ignore) {
printList("typeAnnotations", type.typeAnnotations);
printType("underlyingType", type.underlyingType, Details.FULL);
printList("typeAnnotations", type.getAnnotationMirrors());
printType("underlyingType", type.unannotatedType(), Details.FULL);
return visitType(type, null);
}

1
langtools/test/tools/javac/processing/model/type/BasicAnnoTests.java
View file

@ -26,6 +26,7 @@
* @bug 1234567
* @summary Annotations on types
* @library /tools/javac/lib
* @ignore
* @build JavacTestingAbstractProcessor DPrinter BasicAnnoTests
* @compile/process -processor BasicAnnoTests -proc:only BasicAnnoTests.java
*/