stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8027262: Determine location for type annotations earlier in compiler pipeline

Browse Source 
8027261: Single codepath for attaching annotations to symbols
8027258: Permit a single source annotation to generate multiple bytecode annotations
8027182: Incorrect annotation attributes for type annotations on constructor type parameters
8044010: TypeAnnotation attribute is not generated for repeatable annotation in type argument
8044009: TypeAnnotation attribute is not generated for repeatable annotation in nested types
8043974: TypeAnnotation attribute is not generated for repeatable annotation in lambda
8043669: Few of the ANNOT tests in JCK9 test suite fail with an AssertionError for exception_index
8042060: Type parameter annotations don't work with multiple type parameters
8037348: RuntimeInvisibleAnnotations should not be generated for type annotation on anonymous innerclass creation

Initial rearchitecting of type annotations frontend pipeline

Reviewed-by: jjg, jfranck, mcimadamore, jlahoda, wmdietl
This commit is contained in:
Eric McCorkle 2014-06-06 16:00:59 -04:00
parent bb1f242a9b
commit 8ff3cbd414
54 changed files with 3042 additions and 2379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java
View File

@ -142,7 +142,7 @@ public abstract class Attribute implements AnnotationValue {
* access this attribute.
*/
public final List<Pair<MethodSymbol,Attribute>> values;
public TypeAnnotationPosition position;
public final TypeAnnotationPosition position;
private boolean synthesized = false;
@ -170,53 +170,9 @@ public abstract class Attribute implements AnnotationValue {
@Override
public TypeAnnotationPosition getPosition() {
if (hasUnknownPosition()) {
if (values.size() != 0) {
Name valueName = values.head.fst.name.table.names.value;
Pair<MethodSymbol, Attribute> res = getElemPair(valueName);
position = res == null ? null : res.snd.getPosition();
}
}
return position;
}
public boolean isContainerTypeCompound() {
if (isSynthesized() && values.size() == 1)
return getFirstEmbeddedTC() != null;
return false;
}
private Compound getFirstEmbeddedTC() {
if (values.size() == 1) {
Pair<MethodSymbol, Attribute> val = values.get(0);
if (val.fst.getSimpleName().contentEquals("value")
&& val.snd instanceof Array) {
Array arr = (Array) val.snd;
if (arr.values.length != 0
&& arr.values[0] instanceof Attribute.TypeCompound)
return (Attribute.TypeCompound) arr.values[0];
}
}
return null;
}
public boolean tryFixPosition() {
if (!isContainerTypeCompound())
return false;
Compound from = getFirstEmbeddedTC();
if (from != null && from.position != null &&
from.position.type != TargetType.UNKNOWN) {
position = from.position;
return true;
}
return false;
}
public boolean hasUnknownPosition() {
return position.type == TargetType.UNKNOWN;
}
public void accept(Visitor v) { v.visitCompound(this); }
/**
@ -280,6 +236,12 @@ public abstract class Attribute implements AnnotationValue {
valmap.put(value.fst, value.snd);
return valmap;
}
public TypeCompound toTypeCompound() {
// It is safe to alias the position.
return new TypeCompound(this, this.position);
}
}
public static class TypeCompound extends Compound {

16
langtools/src/share/classes/com/sun/tools/javac/code/TargetType.java
View File

@ -107,10 +107,7 @@ public enum TargetType {
CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT(0x4A, true),
/** For annotations on a type argument of a method reference. */
METHOD_REFERENCE_TYPE_ARGUMENT(0x4B, true),
/** For annotations with an unknown target. */
UNKNOWN(0xFF);
METHOD_REFERENCE_TYPE_ARGUMENT(0x4B, true);
private static final int MAXIMUM_TARGET_TYPE_VALUE = 0x4B;
@ -150,26 +147,15 @@ public enum TargetType {
targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1];
TargetType[] alltargets = values();
for (TargetType target : alltargets) {
if (target.targetTypeValue != UNKNOWN.targetTypeValue)
targets[target.targetTypeValue] = target;
}
for (int i = 0; i <= MAXIMUM_TARGET_TYPE_VALUE; ++i) {
if (targets[i] == null)
targets[i] = UNKNOWN;
}
}
public static boolean isValidTargetTypeValue(int tag) {
if (tag == UNKNOWN.targetTypeValue)
return true;
return (tag >= 0 && tag < targets.length);
}
public static TargetType fromTargetTypeValue(int tag) {
if (tag == UNKNOWN.targetTypeValue)
return UNKNOWN;
if (tag < 0 || tag >= targets.length)
Assert.error("Unknown TargetType: " + tag);
return targets[tag];

24
langtools/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java
View File

@ -259,9 +259,6 @@ public class TypeAnnotationPosition {
case METHOD_RETURN:
case FIELD:
break;
case UNKNOWN:
sb.append(", position UNKNOWN!");
break;
default:
Assert.error("Unknown target type: " + type);
}
@ -428,7 +425,7 @@ public class TypeAnnotationPosition {
}
/**
* Create a {@code TypeAnnotationPosition} for a method receiver.
* Create a {@code TypeAnnotationPosition} for a method receiver parameter.
*
* @param location The type path.
* @param onLambda The lambda for this parameter.
@ -445,7 +442,7 @@ public class TypeAnnotationPosition {
}
/**
* Create a {@code TypeAnnotationPosition} for a method receiver.
* Create a {@code TypeAnnotationPosition} for a method receiver parameter.
*
* @param location The type path.
*/
@ -455,7 +452,7 @@ public class TypeAnnotationPosition {
}
/**
* Create a {@code TypeAnnotationPosition} for a method receiver.
* Create a {@code TypeAnnotationPosition} for a method receiver parameter.
*
* @param pos The position from the associated tree node.
*/
@ -664,10 +661,11 @@ public class TypeAnnotationPosition {
public static TypeAnnotationPosition
exceptionParameter(final List<TypePathEntry> location,
final JCLambda onLambda,
final int type_index,
final int pos) {
return new TypeAnnotationPosition(TargetType.EXCEPTION_PARAMETER, pos,
Integer.MIN_VALUE, onLambda,
Integer.MIN_VALUE, Integer.MIN_VALUE,
type_index, Integer.MIN_VALUE,
location);
}
@ -680,7 +678,7 @@ public class TypeAnnotationPosition {
public static TypeAnnotationPosition
exceptionParameter(final JCLambda onLambda,
final int pos) {
return exceptionParameter(emptyPath, onLambda, pos);
return exceptionParameter(emptyPath, onLambda, Integer.MIN_VALUE, pos);
}
/**
@ -690,7 +688,7 @@ public class TypeAnnotationPosition {
*/
public static TypeAnnotationPosition
exceptionParameter(final List<TypePathEntry> location) {
return exceptionParameter(location, null, -1);
return exceptionParameter(location, null, Integer.MIN_VALUE, -1);
}
@ -1204,12 +1202,4 @@ public class TypeAnnotationPosition {
return methodTypeParameterBound(location, null, parameter_index,
bound_index, -1);
}
// Consider this deprecated on arrival. We eventually want to get
// rid of this value altogether. Do not use it for anything new.
public static final TypeAnnotationPosition unknown =
new TypeAnnotationPosition(TargetType.UNKNOWN, -1,
Integer.MIN_VALUE, null,
Integer.MIN_VALUE, Integer.MIN_VALUE,
emptyPath);
}

1397
langtools/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java
View File

File diff suppressed because it is too large Load Diff

2009
langtools/src/share/classes/com/sun/tools/javac/comp/Annotate.java
View File

File diff suppressed because it is too large Load Diff

527
langtools/src/share/classes/com/sun/tools/javac/comp/Attr.java
View File

@ -91,7 +91,6 @@ public class Attr extends JCTree.Visitor {
final Types types;
final JCDiagnostic.Factory diags;
final Annotate annotate;
final TypeAnnotations typeAnnotations;
final DeferredLintHandler deferredLintHandler;
public static Attr instance(Context context) {
@ -120,7 +119,6 @@ public class Attr extends JCTree.Visitor {
types = Types.instance(context);
diags = JCDiagnostic.Factory.instance(context);
annotate = Annotate.instance(context);
typeAnnotations = TypeAnnotations.instance(context);
deferredLintHandler = DeferredLintHandler.instance(context);
Options options = Options.instance(context);
@ -434,8 +432,7 @@ public class Attr extends JCTree.Visitor {
public Type attribImportQualifier(JCImport tree, Env<AttrContext> env) {
// Attribute qualifying package or class.
JCFieldAccess s = (JCFieldAccess)tree.qualid;
return attribTree(s.selected,
env,
return attribTree(s.selected, env,
new ResultInfo(tree.staticImport ? TYP : (TYP | PCK),
Type.noType));
}
@ -638,7 +635,8 @@ public class Attr extends JCTree.Visitor {
/** Derived visitor method: attribute an expression tree.
*/
public Type attribExpr(JCTree tree, Env<AttrContext> env, Type pt) {
return attribTree(tree, env, new ResultInfo(VAL, !pt.hasTag(ERROR) ? pt : Type.noType));
return attribTree(tree, env,
new ResultInfo(VAL, !pt.hasTag(ERROR) ? pt : Type.noType));
}
/** Derived visitor method: attribute an expression tree with
@ -650,6 +648,7 @@ public class Attr extends JCTree.Visitor {
/** Derived visitor method: attribute a type tree.
*/
public Type attribType(JCTree tree, Env<AttrContext> env) {
Type result = attribType(tree, env, Type.noType);
return result;
@ -664,6 +663,7 @@ public class Attr extends JCTree.Visitor {
/** Derived visitor method: attribute a statement or definition tree.
*/
public Type attribStat(JCTree tree, Env<AttrContext> env) {
return attribTree(tree, env, statInfo);
}
@ -731,7 +731,8 @@ public class Attr extends JCTree.Visitor {
a.tsym.flags_field |= UNATTRIBUTED;
a.bound = Type.noType;
if (!tvar.bounds.isEmpty()) {
List<Type> bounds = List.of(attribType(tvar.bounds.head, env));
List<Type> bounds =
List.of(attribType(tvar.bounds.head, env));
for (JCExpression bound : tvar.bounds.tail)
bounds = bounds.prepend(attribType(bound, env));
types.setBounds(a, bounds.reverse());
@ -765,7 +766,7 @@ public class Attr extends JCTree.Visitor {
* @param type The expected type, or null
* @see VarSymbol#setLazyConstValue
*/
public Object attribLazyConstantValue(Env<AttrContext> env,
public Object attribLazyConstantValue(final Env<AttrContext> env,
JCVariableDecl variable,
Type type) {
@ -884,6 +885,7 @@ public class Attr extends JCTree.Visitor {
c.flags_field |= NOOUTERTHIS;
}
attribClass(tree.pos(), c);
result = tree.type = c.type;
}
}
@ -1021,10 +1023,6 @@ public class Attr extends JCTree.Visitor {
}
}
// Attribute all type annotations in the body
annotate.annotateTypeLater(tree.body, localEnv, m, null);
annotate.flush();
// Attribute method body.
attribStat(tree.body, localEnv);
}
@ -1038,21 +1036,67 @@ public class Attr extends JCTree.Visitor {
}
}
public void visitVarDef(JCVariableDecl tree) {
public Annotate.PositionCreator getVarCreator(final JCVariableDecl tree) {
// Form the enclosing tree node, figure out what kind
// of definition we are looking at.
switch(env.tree.getTag()) {
case TRY:
// If it's a try, then we have a resource variable
return annotate.resourceVarCreator(tree.pos);
case CATCH:
// If it's a catch, then we have an exception parameter
return annotate.exceptionParamCreator(tree.pos);
case LAMBDA: {
// If it's a lambda, then we could have a local
// variable or a parameter.
final JCLambda lambda = (JCLambda) env.tree;
// We have to figure out what the index of the
// parameter is, and unfortunately, the visitor
// and tree APIs don't help us much here. If we
// don't find the declaration in the parameter
// list, then it must be a local variable.
//
// This could easily be replaced by an index
// parameter, which is -1 for non-indexed
// definitions.
int index = -1;
int i = 0;
for (List<JCVariableDecl> l = lambda.params;
l.nonEmpty(); l = l.tail, i++) {
if (l.head == tree) {
index = i;
break;
}
}
if (index == -1) {
return annotate.localVarCreator(tree.pos);
} else {
return annotate.paramCreator(index);
}
}
case CASE:
case BLOCK:
case FORLOOP:
case FOREACHLOOP:
case LABELLED:
// These are all cases where we can end up with a
// local variable.
return annotate.localVarCreator(tree.pos);
default:
// Be strict and throw an error if we see
// something we don't expect.
throw new AssertionError("Unexpected enclosing tree for variable definition: " + env.tree.getTag());
}
}
public void visitVarDef(final JCVariableDecl tree) {
// Local variables have not been entered yet, so we need to do it now:
if (env.info.scope.owner.kind == MTH) {
if (tree.sym != null) {
// parameters have already been entered
env.info.scope.enter(tree.sym);
} else {
memberEnter.memberEnter(tree, env);
annotate.flush();
}
} else {
if (tree.init != null) {
// Field initializer expression need to be entered.
annotate.annotateTypeLater(tree.init, env, tree.sym, tree.pos());
annotate.flush();
memberEnter.memberEnter(tree, env, getVarCreator(tree));
}
}
@ -1103,17 +1147,15 @@ public class Attr extends JCTree.Visitor {
// Block is a static or instance initializer;
// let the owner of the environment be a freshly
// created BLOCK-method.
Env<AttrContext> localEnv =
final Env<AttrContext> localEnv =
env.dup(tree, env.info.dup(env.info.scope.dupUnshared()));
localEnv.info.scope.owner =
new MethodSymbol(tree.flags | BLOCK |
env.info.scope.owner.flags() & STRICTFP, names.empty, null,
env.info.scope.owner);
if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;
// Attribute all type annotations in the block
annotate.annotateTypeLater(tree, localEnv, localEnv.info.scope.owner, null);
annotate.flush();
if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;
attribStats(tree.stats, localEnv);
{
// Store init and clinit type annotations with the ClassSymbol
@ -1126,8 +1168,6 @@ public class Attr extends JCTree.Visitor {
cs.appendInitTypeAttributes(tas);
}
}
attribStats(tree.stats, localEnv);
} else {
// Create a new local environment with a local scope.
Env<AttrContext> localEnv =
@ -1481,17 +1521,21 @@ public class Attr extends JCTree.Visitor {
isBooleanOrNumeric(env, condTree.falsepart);
case APPLY:
JCMethodInvocation speculativeMethodTree =
(JCMethodInvocation)deferredAttr.attribSpeculative(tree, env, unknownExprInfo);
(JCMethodInvocation)deferredAttr.attribSpeculative(tree, env, unknownExprInfo,
annotate.noCreator);
Type owntype = TreeInfo.symbol(speculativeMethodTree.meth).type.getReturnType();
return types.unboxedTypeOrType(owntype).isPrimitive();
case NEWCLASS:
JCExpression className =
removeClassParams.translate(((JCNewClass)tree).clazz);
JCExpression speculativeNewClassTree =
(JCExpression)deferredAttr.attribSpeculative(className, env, unknownTypeInfo);
(JCExpression)deferredAttr.attribSpeculative(className,
env,
unknownTypeInfo,
annotate.newObjCreator(tree.pos));
return types.unboxedTypeOrType(speculativeNewClassTree.type).isPrimitive();
default:
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo).type;
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo, annotate.noCreator).type;
speculativeType = types.unboxedTypeOrType(speculativeType);
return speculativeType.isPrimitive();
}
@ -1754,7 +1798,28 @@ public class Attr extends JCTree.Visitor {
// Attribute arguments, yielding list of argument types.
attribArgs(tree.args, localEnv, argtypesBuf);
argtypes = argtypesBuf.toList();
typeargtypes = attribTypes(tree.typeargs, localEnv);
// Attribute and annotate the type arguments
ListBuffer<Type> typeargtypesbuf = new ListBuffer<>();
int i = 0;
for (List<JCExpression> l = tree.typeargs;
l.nonEmpty(); l = l.tail, i++) {
final JCExpression arg = l.head;
try {
annotate.enterStart();
typeargtypesbuf.append(attribType(arg, localEnv));
annotate.annotateTypeLater(arg, localEnv,
localEnv.info.scope.owner,
tree.pos(),
annotate.constructorInvokeTypeArgCreator(i, tree.pos));
} finally {
annotate.enterDone();
}
}
typeargtypes =
chk.checkRefTypes(tree.typeargs, typeargtypesbuf.toList());
// Variable `site' points to the class in which the called
// constructor is defined.
@ -1827,7 +1892,27 @@ public class Attr extends JCTree.Visitor {
// Attribute the arguments, yielding list of argument types, ...
int kind = attribArgs(tree.args, localEnv, argtypesBuf);
argtypes = argtypesBuf.toList();
typeargtypes = attribAnyTypes(tree.typeargs, localEnv);
// Attribute and annotate the type arguments
ListBuffer<Type> typeargtypesbuf = new ListBuffer<>();
int i = 0;
for (List<JCExpression> l = tree.typeargs;
l.nonEmpty(); l = l.tail, i++) {
final JCExpression arg = l.head;
try {
annotate.enterStart();
typeargtypesbuf.append(attribType(arg, localEnv));
annotate.annotateTypeLater(arg, localEnv,
localEnv.info.scope.owner,
tree.pos(),
annotate.methodInvokeTypeArgCreator(i, tree.pos));
} finally {
annotate.enterDone();
}
}
typeargtypes = typeargtypesbuf.toList();
// ... and attribute the method using as a prototype a methodtype
// whose formal argument types is exactly the list of actual
@ -1852,6 +1937,7 @@ public class Attr extends JCTree.Visitor {
// current context. Also, capture the return type
result = check(tree, capture(restype), VAL, resultInfo);
}
chk.validate(tree.typeargs, localEnv);
}
//where
@ -1927,14 +2013,12 @@ public class Attr extends JCTree.Visitor {
annoclazzid = (JCAnnotatedType) clazzid;
clazzid = annoclazzid.underlyingType;
}
} else {
if (clazz.hasTag(ANNOTATED_TYPE)) {
} else if (clazz.hasTag(ANNOTATED_TYPE)) {
annoclazzid = (JCAnnotatedType) clazz;
clazzid = annoclazzid.underlyingType;
} else {
clazzid = clazz;
}
}
JCExpression clazzid1 = clazzid; // The same in fully qualified form
@ -1956,11 +2040,12 @@ public class Attr extends JCTree.Visitor {
EndPosTable endPosTable = this.env.toplevel.endPositions;
endPosTable.storeEnd(clazzid1, tree.getEndPosition(endPosTable));
if (clazz.hasTag(ANNOTATED_TYPE)) {
JCAnnotatedType annoType = (JCAnnotatedType) clazz;
List<JCAnnotation> annos = annoType.annotations;
if (annoclazzid != null) {
JCAnnotatedType annoType = annoclazzid;
List<JCAnnotation> annos = annoclazzid.annotations;
if (clazz.hasTag(TYPEAPPLY)) {
if (annoType.underlyingType.hasTag(TYPEAPPLY)) {
clazzid1 = make.at(tree.pos).
TypeApply(clazzid1,
((JCTypeApply) clazz).arguments);
@ -1977,12 +2062,32 @@ public class Attr extends JCTree.Visitor {
clazz = clazzid1;
}
Type clazztype;
try {
annotate.enterStart();
// Attribute clazz expression and store
// symbol + type back into the attributed tree.
Type clazztype = TreeInfo.isEnumInit(env.tree) ?
clazztype = TreeInfo.isEnumInit(env.tree) ?
attribIdentAsEnumType(env, (JCIdent)clazz) :
attribType(clazz, env);
if (cdef != null) {
// If we are looking at an anonymous class creation, then
// we are not allowed to have declaration annotations on
// the base type.
annotate.annotateStrictTypeLater(clazz, cdef.mods.annotations, localEnv,
env.info.scope.owner, tree.pos(),
annotate.newObjCreator(tree.pos));
} else {
// Otherwise, we are.
annotate.annotateTypeLater(clazz, localEnv, env.info.scope.owner,
tree.pos(), annotate.newObjCreator(tree.pos));
}
} finally {
annotate.enterDone();
}
clazztype = chk.checkDiamond(tree, clazztype);
chk.validate(clazz, localEnv);
if (tree.encl != null) {
@ -2011,7 +2116,29 @@ public class Attr extends JCTree.Visitor {
ListBuffer<Type> argtypesBuf = new ListBuffer<>();
int pkind = attribArgs(tree.args, localEnv, argtypesBuf);
List<Type> argtypes = argtypesBuf.toList();
List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
List<Type> typeargtypes;
// Attribute and annotate the type arguments
ListBuffer<Type> typeargtypesbuf = new ListBuffer<>();
int i = 0;
for (List<JCExpression> l = tree.typeargs;
l.nonEmpty(); l = l.tail, i++) {
final JCExpression arg = l.head;
try {
annotate.enterStart();
typeargtypesbuf.append(attribType(arg, localEnv));
annotate.annotateTypeLater(arg, localEnv,
localEnv.info.scope.owner,
tree.pos(),
annotate.constructorInvokeTypeArgCreator(i, tree.pos));
} finally {
annotate.enterDone();
}
}
typeargtypes =
chk.checkRefTypes(tree.typeargs, typeargtypesbuf.toList());
// If we have made no mistakes in the class type...
if (clazztype.hasTag(CLASS)) {
@ -2194,7 +2321,9 @@ public class Attr extends JCTree.Visitor {
ta.arguments = List.nil();
ResultInfo findDiamondResult = new ResultInfo(VAL,
resultInfo.checkContext.inferenceContext().free(resultInfo.pt) ? Type.noType : pt());
Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
Type inferred = deferredAttr.attribSpeculative(tree, env,
findDiamondResult,
annotate.newObjCreator(tree.pos)).type;
Type polyPt = allowPoly ?
syms.objectType :
clazztype;
@ -2256,8 +2385,20 @@ public class Attr extends JCTree.Visitor {
Type owntype = types.createErrorType(tree.type);
Env<AttrContext> localEnv = env.dup(tree);
Type elemtype;
for(List<JCAnnotation> dim : tree.dimAnnotations) {
this.attribAnnotationTypes(dim, localEnv);
}
if (tree.elemtype != null) {
try {
annotate.enterStart();
elemtype = attribType(tree.elemtype, localEnv);
annotate.annotateTypeLater(tree, env, env.info.scope.owner, tree.pos(),
annotate.newObjCreator(tree.pos));
} finally {
annotate.enterDone();
}
chk.validate(tree.elemtype, localEnv);
owntype = elemtype;
for (List<JCExpression> l = tree.dims; l.nonEmpty(); l = l.tail) {
@ -2278,6 +2419,7 @@ public class Attr extends JCTree.Visitor {
elemtype = types.createErrorType(pt());
}
}
if (tree.elems != null) {
attribExprs(tree.elems, localEnv, elemtype);
owntype = new ArrayType(elemtype, syms.arrayClass,
@ -2672,6 +2814,8 @@ public class Attr extends JCTree.Visitor {
@Override
public void visitReference(final JCMemberReference that) {
final boolean isConstructor = that.getName() == names.init;
if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {
if (pt().hasTag(NONE)) {
//method reference only allowed in assignment or method invocation/cast context
@ -2682,9 +2826,20 @@ public class Attr extends JCTree.Visitor {
}
final Env<AttrContext> localEnv = env.dup(that);
try {
Type exprType;
try {
annotate.enterStart();
//attribute member reference qualifier - if this is a constructor
//reference, the expected kind must be a type
Type exprType = attribTree(that.expr, env, memberReferenceQualifierResult(that));
exprType = attribTree(that.expr, env, memberReferenceQualifierResult(that));
final Annotate.PositionCreator creator =
isConstructor ? annotate.constructorRefCreator(that.pos) :
annotate.methodRefCreator(that.pos);
annotate.annotateTypeLater(that.expr, localEnv, env.info.scope.owner,
that.pos(), creator);
} finally {
annotate.enterDone();
}
if (that.getMode() == JCMemberReference.ReferenceMode.NEW) {
exprType = chk.checkConstructorRefType(that.expr, exprType);
@ -2714,7 +2869,24 @@ public class Attr extends JCTree.Visitor {
//attrib type-arguments
List<Type> typeargtypes = List.nil();
if (that.typeargs != null) {
try {
annotate.enterStart();
typeargtypes = attribTypes(that.typeargs, localEnv);
// Annotate type arguments
int i = 0;
for (List<JCExpression> l = that.typeargs;
l.nonEmpty(); l = l.tail, i++) {
final Annotate.PositionCreator typeArgCreator =
isConstructor ? annotate.constructorRefTypeArgCreator(i, that.pos) :
annotate.methodRefTypeArgCreator(i, that.pos);
final JCExpression arg = l.head;
annotate.annotateTypeLater(arg, env, env.info.scope.owner,
that.pos(), typeArgCreator);
}
} finally {
annotate.enterDone();
}
}
Type desc;
@ -3088,7 +3260,15 @@ public class Attr extends JCTree.Visitor {
}
public void visitTypeCast(final JCTypeCast tree) {
Type clazztype = attribType(tree.clazz, env);
Type clazztype;
try {
annotate.enterStart();
clazztype = attribType(tree.clazz, env);
annotate.annotateTypeLater(tree.clazz, env, env.info.scope.owner,
tree.pos(), annotate.castCreator(tree.pos));
} finally {
annotate.enterDone();
}
chk.validate(tree.clazz, env, false);
//a fresh environment is required for 292 inference to work properly ---
//see Infer.instantiatePolymorphicSignatureInstance()
@ -3121,7 +3301,16 @@ public class Attr extends JCTree.Visitor {
public void visitTypeTest(JCInstanceOf tree) {
Type exprtype = chk.checkNullOrRefType(
tree.expr.pos(), attribExpr(tree.expr, env));
Type clazztype = attribType(tree.clazz, env);
Type clazztype;
try {
annotate.enterStart();
clazztype = attribType(tree.clazz, env);
annotate.annotateTypeLater(tree.clazz, env, env.info.scope.owner, tree.pos(),
annotate.instanceOfCreator(tree.pos));
} finally {
annotate.enterDone();
}
if (!clazztype.hasTag(TYPEVAR)) {
clazztype = chk.checkClassOrArrayType(tree.clazz.pos(), clazztype);
}
@ -3250,9 +3439,12 @@ public class Attr extends JCTree.Visitor {
if ((pkind() & (PCK | TYP)) == 0)
site = capture(site); // Capture field access
// don't allow T.class T[].class, etc
if (skind == TYP) {
// If the qualifier is a type, annotate it
annotate.annotateTypeLater(tree, env, env.info.scope.owner,
tree.pos(), annotate.errorCreator);
Type elt = site;
// don't allow T.class T[].class, etc
while (elt.hasTag(ARRAY))
elt = ((ArrayType)elt).elemtype;
if (elt.hasTag(TYPEVAR)) {
@ -4081,8 +4273,13 @@ public class Attr extends JCTree.Visitor {
Assert.error("should be handled in Annotate");
}
/* This needs to be removed or otherwise changed, as it implicitly
* relies on the annotated types having previously been visited by
* Annotate.TypeAnnotate.
*/
public void visitAnnotatedType(JCAnnotatedType tree) {
Type underlyingType = attribType(tree.getUnderlyingType(), env);
Type underlyingType = attribTree(tree.getUnderlyingType(), env,
resultInfo);
this.attribAnnotationTypes(tree.annotations, env);
annotateType(tree, tree.annotations);
result = tree.type = underlyingType;
@ -4101,8 +4298,10 @@ public class Attr extends JCTree.Visitor {
public void run() {
List<Attribute.TypeCompound> compounds = fromAnnotations(annotations);
Assert.check(annotations.size() == compounds.size());
if (!tree.type.hasTag(TypeTag.PACKAGE)) {
tree.type = tree.type.annotatedType(compounds);
}
}
});
}
@ -4353,13 +4552,6 @@ public class Attr extends JCTree.Visitor {
checkForSerial(c)) {
checkSerialVersionUID(tree, c);
}
if (allowTypeAnnos) {
// Correctly organize the postions of the type annotations
typeAnnotations.organizeTypeAnnotationsBodies(tree);
// Check type annotations applicability rules
validateTypeAnnotations(tree, false);
}
}
// where
boolean checkForSerial(ClassSymbol c) {
@ -4433,233 +4625,6 @@ public class Attr extends JCTree.Visitor {
return types.capture(type);
}
public void validateTypeAnnotations(JCTree tree, boolean sigOnly) {
tree.accept(new TypeAnnotationsValidator(sigOnly));
}
//where
private final class TypeAnnotationsValidator extends TreeScanner {
private final boolean sigOnly;
public TypeAnnotationsValidator(boolean sigOnly) {
this.sigOnly = sigOnly;
}
public void visitAnnotation(JCAnnotation tree) {
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);
// Don't call super.
// This is needed because above we call validateTypeAnnotation with
// false, which would forbid annotations on type parameters.
// super.visitTypeParameter(tree);
}
public void visitMethodDef(JCMethodDecl tree) {
if (tree.recvparam != null &&
!tree.recvparam.vartype.type.isErroneous()) {
checkForDeclarationAnnotations(tree.recvparam.mods.annotations,
tree.recvparam.vartype.type.tsym);
}
if (tree.restype != null && tree.restype.type != null) {
validateAnnotatedType(tree.restype, tree.restype.type);
}
if (sigOnly) {
scan(tree.mods);
scan(tree.restype);
scan(tree.typarams);
scan(tree.recvparam);
scan(tree.params);
scan(tree.thrown);
} else {
scan(tree.defaultValue);
scan(tree.body);
}
}
public void visitVarDef(final JCVariableDecl tree) {
//System.err.println("validateTypeAnnotations.visitVarDef " + tree);
if (tree.sym != null && tree.sym.type != null)
validateAnnotatedType(tree.vartype, tree.sym.type);
scan(tree.mods);
scan(tree.vartype);
if (!sigOnly) {
scan(tree.init);
}
}
public void visitTypeCast(JCTypeCast tree) {
if (tree.clazz != null && tree.clazz.type != null)
validateAnnotatedType(tree.clazz, tree.clazz.type);
super.visitTypeCast(tree);
}
public void visitTypeTest(JCInstanceOf tree) {
if (tree.clazz != null && tree.clazz.type != null)
validateAnnotatedType(tree.clazz, tree.clazz.type);
super.visitTypeTest(tree);
}
public void visitNewClass(JCNewClass tree) {
if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
checkForDeclarationAnnotations(((JCAnnotatedType) tree.clazz).annotations,
tree.clazz.type.tsym);
}
if (tree.def != null) {
checkForDeclarationAnnotations(tree.def.mods.annotations, tree.clazz.type.tsym);
}
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.type != null) {
if (tree.elemtype.hasTag(ANNOTATED_TYPE)) {
checkForDeclarationAnnotations(((JCAnnotatedType) tree.elemtype).annotations,
tree.elemtype.type.tsym);
}
validateAnnotatedType(tree.elemtype, tree.elemtype.type);
}
super.visitNewArray(tree);
}
public void visitClassDef(JCClassDecl tree) {
//System.err.println("validateTypeAnnotations.visitClassDef " + tree);
if (sigOnly) {
scan(tree.mods);
scan(tree.typarams);
scan(tree.extending);
scan(tree.implementing);
}
for (JCTree member : tree.defs) {
if (member.hasTag(Tag.CLASSDEF)) {
continue;
}
scan(member);
}
}
public void visitBlock(JCBlock tree) {
if (!sigOnly) {
scan(tree.stats);
}
}
/* I would want to model this after
* com.sun.tools.javac.comp.Check.Validator.visitSelectInternal(JCFieldAccess)
* and override visitSelect and visitTypeApply.
* However, we only set the annotated type in the top-level type
* of the symbol.
* Therefore, we need to override each individual location where a type
* can occur.
*/
private void validateAnnotatedType(final JCTree errtree, final Type type) {
//System.err.println("Attr.validateAnnotatedType: " + errtree + " type: " + type);
if (type.isPrimitiveOrVoid()) {
return;
}
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<>();
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).getExtendsBound());
} else if (wc.getKind() == JCTree.Kind.SUPER_WILDCARD) {
validateAnnotatedType(wc.getBound(), ((WildcardType)enclTy).getSuperBound());
} else {
// Nothing to do for UNBOUND
}
repeat = false;
} else if (enclTr.hasTag(TYPEARRAY)) {
JCArrayTypeTree art = (JCArrayTypeTree) enclTr;
validateAnnotatedType(art.getType(), ((ArrayType)enclTy).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 ||
enclTr.getKind() == JCTree.Kind.ERRONEOUS) {
repeat = false;
} else {
Assert.error("Unexpected tree: " + enclTr + " with kind: " + enclTr.getKind() +
" within: "+ errtree + " with kind: " + errtree.getKind());
}
}
}
private void checkForDeclarationAnnotations(List<? extends JCAnnotation> annotations,
Symbol sym) {
// Ensure that no declaration annotations are present.
// Note that a tree type might be an AnnotatedType with
// empty annotations, if only declaration annotations were given.
// This method will raise an error for such a type.
for (JCAnnotation ai : annotations) {
if (!ai.type.isErroneous() &&
typeAnnotations.annotationType(ai.attribute, sym) == TypeAnnotations.AnnotationType.DECLARATION) {
log.error(ai.pos(), "annotation.type.not.applicable");
}
}
}
}
// <editor-fold desc="post-attribution visitor">
/**

6
langtools/src/share/classes/com/sun/tools/javac/comp/AttrContext.java
View File

@ -58,6 +58,11 @@ public class AttrContext {
*/
boolean isSerializable = false;
/**
* Are we doing speculative attribution?
*/
boolean isSpeculative = false;
/** Are arguments to current function applications boxed into an array for varargs?
*/
Resolve.MethodResolutionPhase pendingResolutionPhase = null;
@ -94,6 +99,7 @@ public class AttrContext {
info.returnResult = returnResult;
info.defaultSuperCallSite = defaultSuperCallSite;
info.isSerializable = isSerializable;
info.isSpeculative = isSpeculative;
return info;
}

41
langtools/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java
View File

@ -25,6 +25,7 @@
package com.sun.tools.javac.comp;
import com.sun.source.tree.*;
import com.sun.source.tree.LambdaExpressionTree.BodyKind;
import com.sun.tools.javac.code.*;
import com.sun.tools.javac.tree.*;
@ -76,6 +77,7 @@ public class DeferredAttr extends JCTree.Visitor {
final Types types;
final Flow flow;
final Names names;
final Annotate annotate;
public static DeferredAttr instance(Context context) {
DeferredAttr instance = context.get(deferredAttrKey);
@ -99,6 +101,7 @@ public class DeferredAttr extends JCTree.Visitor {
flow = Flow.instance(context);
names = Names.instance(context);
stuckTree = make.Ident(names.empty).setType(Type.stuckType);
annotate = Annotate.instance(context);
emptyDeferredAttrContext =
new DeferredAttrContext(AttrMode.CHECK, null, MethodResolutionPhase.BOX, infer.emptyContext, null, null) {
@Override
@ -133,7 +136,8 @@ public class DeferredAttr extends JCTree.Visitor {
AttrMode mode;
SpeculativeCache speculativeCache;
DeferredType(JCExpression tree, Env<AttrContext> env) {
DeferredType(JCExpression tree,
Env<AttrContext> env) {
super(null, noAnnotations);
this.tree = tree;
this.env = attr.copyEnv(env);
@ -277,12 +281,18 @@ public class DeferredAttr extends JCTree.Visitor {
//Note: if a symbol is imported twice we might do two identical
//speculative rounds...
Assert.check(dt.mode == null || dt.mode == AttrMode.SPECULATIVE);
JCTree speculativeTree = attribSpeculative(dt.tree, dt.env, resultInfo);
JCTree speculativeTree = attribSpeculative(dt.tree, dt.env,
resultInfo,
annotate.noCreator);
dt.speculativeCache.put(speculativeTree, resultInfo);
return speculativeTree.type;
case CHECK:
Assert.check(dt.mode != null);
return attr.attribTree(dt.tree, dt.env, resultInfo);
final boolean oldSpeculative = dt.env.info.isSpeculative;
dt.env.info.isSpeculative = false;
Type out = attr.attribTree(dt.tree, dt.env, resultInfo);
dt.env.info.isSpeculative = oldSpeculative;
return out;
}
Assert.error();
return null;
@ -359,9 +369,13 @@ public class DeferredAttr extends JCTree.Visitor {
* restored after type-checking. All diagnostics (but critical ones) are
* disabled during speculative type-checking.
*/
JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
JCTree attribSpeculative(JCTree tree,
Env<AttrContext> env,
ResultInfo resultInfo,
Annotate.PositionCreator creator) {
final JCTree newTree = new TreeCopier<>(make).copy(tree);
Env<AttrContext> speculativeEnv = env.dup(newTree, env.info.dup(env.info.scope.dupUnshared()));
speculativeEnv.info.isSpeculative = true;
speculativeEnv.info.scope.owner = env.info.scope.owner;
Log.DeferredDiagnosticHandler deferredDiagnosticHandler =
new Log.DeferredDiagnosticHandler(log, new Filter<JCDiagnostic>() {
@ -385,6 +399,9 @@ public class DeferredAttr extends JCTree.Visitor {
});
try {
attr.attribTree(newTree, speculativeEnv, resultInfo);
annotate.typeAnnotateExprLater(newTree, speculativeEnv,
speculativeEnv.info.scope.owner,
newTree.pos(), creator);
unenterScanner.scan(newTree);
return newTree;
} finally {
@ -741,8 +758,11 @@ public class DeferredAttr extends JCTree.Visitor {
checkContext.report(null, ex.getDiagnostic());
}
Env<AttrContext> localEnv = env.dup(tree);
JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
attr.memberReferenceQualifierResult(tree));
JCExpression exprTree =
(JCExpression)attribSpeculative(tree.getQualifierExpression(),
localEnv,
attr.memberReferenceQualifierResult(tree),
annotate.methodRefCreator(tree.pos));
ListBuffer<Type> argtypes = new ListBuffer<>();
for (Type t : types.findDescriptorType(pt).getParameterTypes()) {
argtypes.append(Type.noType);
@ -1164,8 +1184,11 @@ public class DeferredAttr extends JCTree.Visitor {
public void visitReference(JCMemberReference tree) {
//perform arity-based check
Env<AttrContext> localEnv = env.dup(tree);
JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
attr.memberReferenceQualifierResult(tree));
JCExpression exprTree =
(JCExpression)attribSpeculative(tree.getQualifierExpression(),
localEnv,
attr.memberReferenceQualifierResult(tree),
annotate.methodRefCreator(tree.pos));
JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
mref2.expr = exprTree;
Symbol res =
@ -1309,7 +1332,7 @@ public class DeferredAttr extends JCTree.Visitor {
return null;
site = resolvedReturnType.type;
} else {
site = attribSpeculative(rec, env, attr.unknownTypeExprInfo).type;
site = attribSpeculative(rec, env, attr.unknownTypeExprInfo, annotate.noCreator).type;
}
} else {
site = env.enclClass.sym.type;

7
langtools/src/share/classes/com/sun/tools/javac/comp/Env.java
View File

@ -26,6 +26,7 @@
package com.sun.tools.javac.comp;
import com.sun.tools.javac.tree.*;
import com.sun.tools.javac.tree.JCTree.JCLambda;
import java.util.Iterator;
import java.util.NoSuchElementException;
@ -156,4 +157,10 @@ public class Env<A> implements Iterable<Env<A>> {
}
};
}
public JCLambda getLambda() {
Env<A> out = enclosing(JCTree.Tag.LAMBDA);
return out != null ? (JCLambda) out.tree : null;
}
}

258
langtools/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java
View File

@ -35,8 +35,9 @@ import com.sun.tools.javac.jvm.*;
import com.sun.tools.javac.tree.*;
import com.sun.tools.javac.util.*;
import com.sun.tools.javac.code.Type.*;
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.code.Type.*;
import com.sun.tools.javac.code.TypeAnnotationPosition.*;
import com.sun.tools.javac.tree.JCTree.*;
import static com.sun.tools.javac.code.Flags.*;
@ -75,7 +76,6 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
private final TreeMaker make;
private final Todo todo;
private final Annotate annotate;
private final TypeAnnotations typeAnnotations;
private final Types types;
private final JCDiagnostic.Factory diags;
private final Source source;
@ -101,7 +101,6 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
make = TreeMaker.instance(context);
todo = Todo.instance(context);
annotate = Annotate.instance(context);
typeAnnotations = TypeAnnotations.instance(context);
types = Types.instance(context);
diags = JCDiagnostic.Factory.instance(context);
source = Source.instance(context);
@ -131,6 +130,13 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
*/
boolean completionEnabled = true;
/** The creator that will be used for any varDef's we visit. This
* is used to create the position for any type annotations (or
* annotations that potentially are type annotations) that we
* encounter.
*/
Annotate.PositionCreator creator;
/* ---------- Processing import clauses ----------------
*/
@ -348,6 +354,7 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
/** Construct method type from method signature.
* @param msym The MethodSymbol for the method.
* @param typarams The method's type parameters.
* @param params The method's value parameters.
* @param res The method's result type,
@ -356,33 +363,89 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
* null if none given; TODO: or already set here?
* @param thrown The method's thrown exceptions.
* @param env The method's (local) environment.
* @param declAnnos The annotations on the method declaration,
* some of which may be type annotations on
* the return type.
* @param deferPos The deferred diagnostic position for error
* reporting.
*/
Type signature(MethodSymbol msym,
List<JCTypeParameter> typarams,
List<JCVariableDecl> params,
JCTree res,
JCVariableDecl recvparam,
List<JCExpression> thrown,
Env<AttrContext> env) {
Type signature(final MethodSymbol msym,
final List<JCTypeParameter> typarams,
final List<JCVariableDecl> params,
final JCTree res,
final JCVariableDecl recvparam,
final List<JCExpression> thrown,
final Env<AttrContext> env,
final List<JCAnnotation> declAnnos,
final DiagnosticPosition deferPos) {
int i;
// Enter and attribute type parameters.
List<Type> tvars = enter.classEnter(typarams, env);
attr.attribTypeVariables(typarams, env);
// Enter and attribute value parameters.
// Handle type annotations on type parameters.
i = 0;
for (List<JCTypeParameter> l = typarams; l.nonEmpty();
l = l.tail, i++) {
final JCTypeParameter param = l.head;
annotate.annotateTypeLater(param, env, msym, deferPos,
annotate.methodTypeParamCreator(i));
// ...and bounds on type parameters.
int j = 0;
for (List<JCExpression> bounds = param.bounds;
bounds.nonEmpty(); bounds = bounds.tail, j++) {
annotate.annotateTypeLater(bounds.head, env, msym, deferPos,
annotate.methodTypeParamBoundCreator(param, i, j));
}
}
// Enter and attribute value parameters. Type annotations get
// METHOD_FORMAL_PARAMETER positions.
ListBuffer<Type> argbuf = new ListBuffer<>();
for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail) {
memberEnter(l.head, env);
i = 0;
for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail, i++) {
// The types will get annotated by visitVarDef
memberEnter(l.head, env, annotate.paramCreator(i));
argbuf.append(l.head.vartype.type);
}
// Attribute result type, if one is given.
Type restype = res == null ? syms.voidType : attr.attribType(res, env);
Type restype;
if (res != null) {
// If we have any declaration annotations, they might
// be/also be type annotations on the return type. We
// pass them in, so they get classified and then attached
// to the method, or the return type, or both.
restype = attr.attribType(res, env);
annotate.annotateTypeLater(res, declAnnos, env, msym, deferPos,
annotate.returnCreator);
} else {
// For constructors, we don't actually have a type, so we
// can't have a type path (except for INNER_TYPE), and we
// don't have annotations on arrays, type arguments, and
// the like.
// The only type path we have is if we are in an inner type.
List<TypePathEntry> typepath = Annotate.makeInners(msym.owner.type);
TypeAnnotationPosition tapos =
TypeAnnotationPosition.methodReturn(typepath, env.getLambda(), -1);
// We don't have to walk down a type. We just have to do
// repeating annotation handling, then classify and attach
// the annotations.
annotate.annotateWithClassifyLater(declAnnos, env, msym,
deferPos, tapos);
restype = syms.voidType;
}
// Attribute receiver type, if one is given.
Type recvtype;
if (recvparam!=null) {
memberEnter(recvparam, env);
// The type will get annotated by visitVarDef
memberEnter(recvparam, env, annotate.receiverCreator);
recvtype = recvparam.vartype.type;
} else {
recvtype = null;
@ -390,8 +453,12 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
// Attribute thrown exceptions.
ListBuffer<Type> thrownbuf = new ListBuffer<>();
for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail) {
i = 0;
for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail, i++) {
Type exc = attr.attribType(l.head, env);
// Annotate each exception type.
annotate.annotateTypeLater(l.head, env, msym, deferPos,
annotate.throwCreator(i));
if (!exc.hasTag(TYPEVAR)) {
exc = chk.checkClassType(l.head.pos(), exc);
} else if (exc.tsym.owner == msym) {
@ -420,33 +487,49 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
/** Enter field and method definitions and process import
* clauses, catching any completion failure exceptions.
*/
protected void memberEnter(JCTree tree, Env<AttrContext> env) {
protected void memberEnter(JCTree tree, Env<AttrContext> env,
Annotate.PositionCreator creator) {
Env<AttrContext> prevEnv = this.env;
Annotate.PositionCreator prevCreator = this.creator;
try {
this.env = env;
this.creator = creator;
tree.accept(this);
} catch (CompletionFailure ex) {
chk.completionError(tree.pos(), ex);
} finally {
this.creator = prevCreator;
this.env = prevEnv;
}
}
protected void memberEnter(JCTree tree, Env<AttrContext> env) {
memberEnter(tree, env, annotate.noCreator);
}
/** Enter members from a list of trees.
*/
void memberEnter(List<? extends JCTree> trees, Env<AttrContext> env) {
void memberEnter(List<? extends JCTree> trees,
Env<AttrContext> env,
Annotate.PositionCreator creator) {
for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
memberEnter(l.head, env);
memberEnter(l.head, env, creator);
}
void memberEnter(List<? extends JCTree> trees,
Env<AttrContext> env) {
memberEnter(trees, env, annotate.noCreator);
}
/** Enter members for a class.
*/
void finishClass(JCClassDecl tree, Env<AttrContext> env) {
void finishClass(final JCClassDecl tree, final Env<AttrContext> env) {
if ((tree.mods.flags & Flags.ENUM) != 0 &&
(types.supertype(tree.sym.type).tsym.flags() & Flags.ENUM) == 0) {
addEnumMembers(tree, env);
}
memberEnter(tree.defs, env);
memberEnter(tree.defs, env, annotate.fieldCreator);
}
/** Add the implicit members for an enum type
@ -521,7 +604,7 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
}
// process package annotations
annotate.annotateLater(tree.annotations, env, env.toplevel.packge, null);
annotate.annotateLater(tree.annotations, env, env.toplevel.packge);
}
// process the non-static imports and the static imports of types.
@ -567,15 +650,13 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
Env<AttrContext> localEnv = methodEnv(tree, env);
annotate.enterStart();
try {
DiagnosticPosition prevLintPos = deferredLintHandler.setPos(tree.pos());
try {
// Compute the method type
m.type = signature(m, tree.typarams, tree.params,
tree.restype, tree.recvparam,
tree.thrown,
localEnv);
tree.thrown, localEnv,
tree.mods.annotations, tree.pos());
} finally {
deferredLintHandler.setPos(prevLintPos);
}
@ -602,16 +683,9 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
enclScope.enter(m);
}
annotate.annotateLater(tree.mods.annotations, localEnv, m, tree.pos());
// Visit the signature of the method. Note that
// TypeAnnotate doesn't descend into the body.
annotate.annotateTypeLater(tree, localEnv, m, tree.pos());
if (tree.defaultValue != null)
annotateDefaultValueLater(tree.defaultValue, localEnv, m);
} finally {
annotate.enterDone();
}
annotateDefaultValueLater(tree.defaultValue, localEnv,
m, annotate.noCreator);
}
/** Create a fresh environment for method bodies.
@ -695,8 +769,18 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
chk.checkTransparentVar(tree.pos(), v, enclScope);
enclScope.enter(v);
}
annotate.annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
annotate.annotateTypeLater(tree.vartype, env, v, tree.pos());
if (tree.name.equals(names._this)) {
// If we are dealing with a receiver parameter, then
// we only allow base type annotations to be type
// annotations. Receivers are not allowed to have
// declaration annotations.
annotate.annotateStrictTypeLater(tree.vartype, tree.mods.annotations,
localEnv, v, tree.pos(), creator);
} else {
// Otherwise, we annotate the type.
annotate.annotateTypeLater(tree.vartype, tree.mods.annotations,
localEnv, v, tree.pos(), creator);
}
v.pos = tree.pos;
} finally {
annotate.enterDone();
@ -849,7 +933,8 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
/** Queue processing of an attribute default value. */
void annotateDefaultValueLater(final JCExpression defaultValue,
final Env<AttrContext> localEnv,
final MethodSymbol m) {
final MethodSymbol m,
final Annotate.PositionCreator creator) {
annotate.normal(new Annotate.Worker() {
@Override
public String toString() {
@ -936,22 +1021,44 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
// create an environment for evaluating the base clauses
Env<AttrContext> baseEnv = baseEnv(tree, env);
if (tree.extending != null)
annotate.annotateTypeLater(tree.extending, baseEnv, sym, tree.pos());
for (JCExpression impl : tree.implementing)
annotate.annotateTypeLater(impl, baseEnv, sym, tree.pos());
annotate.flush();
// Annotations.
// In general, we cannot fully process annotations yet, but we
// can attribute the annotation types and then check to see if the
// @Deprecated annotation is present.
attr.attribAnnotationTypes(tree.mods.annotations, baseEnv);
if (hasDeprecatedAnnotation(tree.mods.annotations))
c.flags_field |= DEPRECATED;
// Don't attach declaration annotations to anonymous
// classes, they get handled specially below.
if (!sym.isAnonymous()) {
annotate.annotateLater(tree.mods.annotations, baseEnv,
c, tree.pos());
}
// Determine supertype.
Type supertype =
(tree.extending != null)
? attr.attribBase(tree.extending, baseEnv, true, false, true)
: ((tree.mods.flags & Flags.ENUM) != 0)
Type supertype;
if (tree.extending != null) {
supertype = attr.attribBase(tree.extending, baseEnv,
true, false, true);
if (sym.isAnonymous()) {
annotate.annotateAnonClassDefLater(tree.extending,
tree.mods.annotations,
baseEnv, sym, tree.pos(),
annotate.extendsCreator);
} else {
annotate.annotateTypeLater(tree.extending, baseEnv, sym,
tree.pos(), annotate.extendsCreator);
}
} else {
supertype = ((tree.mods.flags & Flags.ENUM) != 0)
? attr.attribBase(enumBase(tree.pos, c), baseEnv,
true, false, false)
: (c.fullname == names.java_lang_Object)
? Type.noType
: syms.objectType;
}
ct.supertype_field = modelMissingTypes(supertype, tree.extending, false);
// Determine interfaces.
@ -959,18 +1066,33 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
ListBuffer<Type> all_interfaces = null; // lazy init
Set<Type> interfaceSet = new HashSet<>();
List<JCExpression> interfaceTrees = tree.implementing;
int i = 0;
for (JCExpression iface : interfaceTrees) {
Type i = attr.attribBase(iface, baseEnv, false, true, true);
if (i.hasTag(CLASS)) {
interfaces.append(i);
if (all_interfaces != null) all_interfaces.append(i);
chk.checkNotRepeated(iface.pos(), types.erasure(i), interfaceSet);
Type it = attr.attribBase(iface, baseEnv, false, true, true);
if (it.hasTag(CLASS)) {
interfaces.append(it);
if (all_interfaces != null) all_interfaces.append(it);
chk.checkNotRepeated(iface.pos(), types.erasure(it), interfaceSet);
} else {
if (all_interfaces == null)
all_interfaces = new ListBuffer<Type>().appendList(interfaces);
all_interfaces.append(modelMissingTypes(i, iface, true));
all_interfaces.append(modelMissingTypes(it, iface, true));
}
if (sym.isAnonymous()) {
// Note: if an anonymous class ever has more than
// one supertype for some reason, this will
// incorrectly attach tree.mods.annotations to ALL
// supertypes, not just the first.
annotate.annotateAnonClassDefLater(iface, tree.mods.annotations,
baseEnv, sym, tree.pos(),
annotate.implementsCreator(i++));
} else {
annotate.annotateTypeLater(iface, baseEnv, sym, tree.pos(),
annotate.implementsCreator(i++));
}
}
if ((c.flags_field & ANNOTATION) != 0) {
ct.interfaces_field = List.of(syms.annotationType);
ct.all_interfaces_field = ct.interfaces_field;
@ -993,22 +1115,28 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
}
// Annotations.
// In general, we cannot fully process annotations yet, but we
// can attribute the annotation types and then check to see if the
// @Deprecated annotation is present.
attr.attribAnnotationTypes(tree.mods.annotations, baseEnv);
if (hasDeprecatedAnnotation(tree.mods.annotations))
c.flags_field |= DEPRECATED;
annotate.annotateLater(tree.mods.annotations, baseEnv, c, tree.pos());
// class type parameters use baseEnv but everything uses env
chk.checkNonCyclicDecl(tree);
attr.attribTypeVariables(tree.typarams, baseEnv);
// Do this here, where we have the symbol.
for (JCTypeParameter tp : tree.typarams)
annotate.annotateTypeLater(tp, baseEnv, sym, tree.pos());
int j = 0;
for (List<JCTypeParameter> l = tree.typarams; l.nonEmpty();
l = l.tail, j++) {
final JCTypeParameter typaram = l.head;
annotate.annotateTypeLater(typaram, baseEnv, sym, tree.pos(),
annotate.typeParamCreator(j));
int k = 0;
for(List<JCExpression> b = typaram.bounds; b.nonEmpty();
b = b.tail, k++) {
final JCExpression bound = b.head;
annotate.annotateTypeLater(bound, baseEnv, sym, tree.pos(),
annotate.typeParamBoundCreator(typaram, j, k));
}
}
// Add default constructor if needed.
if ((c.flags() & INTERFACE) == 0 &&
@ -1088,10 +1216,6 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
while (halfcompleted.nonEmpty()) {
Env<AttrContext> toFinish = halfcompleted.next();
finish(toFinish);
if (allowTypeAnnos) {
typeAnnotations.organizeTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
typeAnnotations.validateTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
}
}
} finally {
isFirst = true;

2
langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java
View File

@ -1611,8 +1611,6 @@ public class ClassReader {
return TypeAnnotationPosition.methodReturn(readTypePath());
case FIELD:
return TypeAnnotationPosition.field(readTypePath());
case UNKNOWN:
throw new AssertionError("jvm.ClassReader: UNKNOWN target type should never occur!");
default:
throw new AssertionError("jvm.ClassReader: Unknown target type for position: " + type);
}

22
langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java
View File

@ -768,25 +768,13 @@ public class ClassWriter extends ClassFile {
ListBuffer<Attribute.TypeCompound> invisibles = new ListBuffer<>();
for (Attribute.TypeCompound tc : typeAnnos) {
if (tc.hasUnknownPosition()) {
boolean fixed = tc.tryFixPosition();
// Could we fix it?
if (!fixed) {
// This happens for nested types like @A Outer. @B Inner.
// For method parameters we get the annotation twice! Once with
// a valid position, once unknown.
// TODO: find a cleaner solution.
PrintWriter pw = log.getWriter(Log.WriterKind.ERROR);
pw.println("ClassWriter: Position UNKNOWN in type annotation: " + tc);
Assert.checkNonNull(tc.position);
if (tc.position.type.isLocal() != inCode) {
continue;
}
if (!tc.position.emitToClassfile()) {
continue;
}
if (tc.position.type.isLocal() != inCode)
continue;
if (!tc.position.emitToClassfile())
continue;
switch (types.getRetention(tc)) {
case SOURCE: break;
case CLASS: invisibles.append(tc); break;
@ -967,8 +955,6 @@ public class ClassWriter extends ClassFile {
case METHOD_RETURN:
case FIELD:
break;
case UNKNOWN:
throw new AssertionError("jvm.ClassWriter: UNKNOWN target type should never occur!");
default:
throw new AssertionError("jvm.ClassWriter: Unknown target type for position: " + p);
}

18
langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java
View File

@ -557,7 +557,6 @@ public class Gen extends JCTree.Visitor {
ListBuffer<Attribute.TypeCompound> fieldTAs = new ListBuffer<>();
ListBuffer<Attribute.TypeCompound> nonfieldTAs = new ListBuffer<>();
for (TypeCompound ta : tas) {
Assert.check(ta.getPosition().type != TargetType.UNKNOWN);
if (ta.getPosition().type == TargetType.FIELD) {
fieldTAs.add(ta);
} else {
@ -1931,10 +1930,7 @@ public class Gen extends JCTree.Visitor {
|| code.meth.getKind() == javax.lang.model.element.ElementKind.STATIC_INIT;
for (Attribute.TypeCompound ta : meth.getRawTypeAttributes()) {
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
if (ta.position != null && ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
@ -1942,10 +1938,7 @@ public class Gen extends JCTree.Visitor {
return;
for (Attribute.TypeCompound ta : meth.owner.getRawTypeAttributes()) {
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
if (ta.position != null && ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
@ -1955,10 +1948,7 @@ public class Gen extends JCTree.Visitor {
continue;
for (Attribute.TypeCompound ta : s.getRawTypeAttributes()) {
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
if (ta.position != null && ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
}
@ -2330,8 +2320,8 @@ public class Gen extends JCTree.Visitor {
}
public void visitTypeTest(JCInstanceOf tree) {
setTypeAnnotationPositions(tree.pos);
genExpr(tree.expr, tree.expr.type).load();
setTypeAnnotationPositions(tree.pos);
code.emitop2(instanceof_, makeRef(tree.pos(), tree.clazz.type));
result = items.makeStackItem(syms.booleanType);
}

90
langtools/test/tools/javac/annotations/typeAnnotations/TargetTypes.java
View File

@ -35,9 +35,41 @@ import java.io.*;
* @compile TargetTypes.java
*/
@Target({TYPE_USE, TYPE_PARAMETER, TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface A {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface A {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface B {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface C {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface D {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface E {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface F {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface G {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface H {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface I {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface J {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface K {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface L {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface M {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface N {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface O {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface P {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface Q {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface R {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface S {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface U {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface V {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface W {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface X {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface Y {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface Z {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AA {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AB {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AC {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AD {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AE {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AF {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AG {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AH {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AI {}
@Target({TYPE_USE, TYPE_PARAMETER, TYPE}) @Retention(RetentionPolicy.RUNTIME) @interface AJ {}
/** wildcard bound */
class T0x1C {
@ -46,75 +78,75 @@ class T0x1C {
/** wildcard bound generic/array */
class T0x1D<T> {
void m0x1D(List<? extends @A List<int[]>> lst) {}
void m0x1D(List<? extends @B List<int[]>> lst) {}
}
/** typecast */
class T0x00 {
void m0x00(Long l1) {
Object l2 = (@A Long) l1;
Object l2 = (@C Long) l1;
}
}
/** typecast generic/array */
class T0x01<T> {
void m0x01(List<T> list) {
List<T> l = (List<@A T>) list;
List<T> l = (List<@D T>) list;
}
}
/** instanceof */
class T0x02 {
boolean m0x02(String s) {
return (s instanceof @A String);
return (s instanceof @E String);
}
}
/** object creation (new) */
class T0x04 {
void m0x04() {
new @A ArrayList<String>();
new @F ArrayList<String>();
}
}
/** local variable */
class T0x08 {
void m0x08() {
@A String s = null;
@G String s = null;
}
}
/** method parameter generic/array */
class T0x0D {
void m0x0D(HashMap<@A Object, List<@A List<@A Class>>> s1) {}
void m0x0D(HashMap<@H Object, List<@I List<@J Class>>> s1) {}
}
/** method receiver */
class T0x06 {
void m0x06(@A T0x06 this) {}
void m0x06(@K T0x06 this) {}
}
/** method return type generic/array */
class T0x0B {
Class<@A Object> m0x0B() { return null; }
Class<@L Object> m0x0B() { return null; }
}
/** field generic/array */
class T0x0F {
HashMap<@A Object, @A Object> c1;
HashMap<@M Object, @N Object> c1;
}
/** method type parameter */
class T0x20<T, U> {
<@A T, @A U> void m0x20() {}
<@O T, @P U> void m0x20() {}
}
/** class type parameter */
class T0x22<@A T, @A U> {
class T0x22<@Q T, @R U> {
}
/** class type parameter bound */
class T0x10<T extends @A Object> {
class T0x10<T extends @S Object> {
}
/** method type parameter bound */
@ -123,43 +155,43 @@ class T0x12<T> {
}
/** class type parameter bound generic/array */
class T0x11<T extends List<@A T>> {
class T0x11<T extends List<@U T>> {
}
/** method type parameter bound generic/array */
class T0x13 {
static <T extends Comparable<@A T>> T m0x13() {
static <T extends Comparable<@V T>> T m0x13() {
return null;
}
}
/** class extends/implements generic/array */
class T0x15<T> extends ArrayList<@A T> {
class T0x15<T> extends ArrayList<@W T> {
}
/** type test (instanceof) generic/array */
class T0x03<T> {
void m0x03(T typeObj, Object obj) {
boolean ok = obj instanceof String @A [];
boolean ok = obj instanceof String @X [];
}
}
/** object creation (new) generic/array */
class T0x05<T> {
void m0x05() {
new ArrayList<@A T>();
new ArrayList<@Y T>();
}
}
/** local variable generic/array */
class T0x09<T> {
void g() {
List<@A String> l = null;
List<@Z String> l = null;
}
void a() {
String @A [] as = null;
String @AA [] as = null;
}
}
@ -168,14 +200,14 @@ class T0x19 {
<T> T0x19() {}
void g() {
new <List<@A String>> T0x19();
new <List<@AB String>> T0x19();
}
}
/** type argument in method call generic/array */
class T0x1B<T> {
void m0x1B() {
Collections.<T @A []>emptyList();
Collections.<T @AC []>emptyList();
}
}
@ -184,7 +216,7 @@ class T0x18<T> {
<T> T0x18() {}
void m() {
new <@A Integer> T0x18();
new <@AD Integer> T0x18();
}
}
@ -192,15 +224,15 @@ class T0x18<T> {
class T0x1A<T,U> {
public static <T, U> T m() { return null; }
static void m0x1A() {
T0x1A.<@A Integer, @A Short>m();
T0x1A.<@AE Integer, @AF Short>m();
}
}
/** class extends/implements */
class T0x14 extends @A Object implements @A Serializable, @A Cloneable {
class T0x14 extends @AG Object implements @AH Serializable, @AI Cloneable {
}
/** exception type in throws */
class T0x16 {
void m0x16() throws @A Exception {}
void m0x16() throws @AJ Exception {}
}

4
langtools/test/tools/javac/annotations/typeAnnotations/classfile/ClassfileTestHelper.java
View File

@ -36,8 +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 print(String msg) { if (verbose) System.out.print(msg); }
void println(String msg) { if (verbose) System.err.println(msg); }
void print(String msg) { if (verbose) System.err.print(msg); }
File writeTestFile(String fname, String source) throws IOException {
File f = new File(fname);

17
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedClassExpr.java Normal file
View File

@ -0,0 +1,17 @@
/*
* @test /nodynamiccopyright/
* @bug 8027262
* @summary A class expression cannot be annotated.
* @compile/fail/ref=AnnotatedClassExpr.out -XDrawDiagnostics AnnotatedClassExpr.java
*/
import java.lang.annotation.*;
import java.util.List;
class AnnotatedClassExpr {
static void main() {
Object o1 = @A int.class;
}
}
@Target(ElementType.TYPE_USE)
@interface A { }

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

@ -0,0 +1,2 @@
AnnotatedClassExpr.java:12:29: compiler.err.no.annotations.on.dot.class
1 error

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

@ -1,9 +1,8 @@
/*
* @test /nodynamiccopyright/
* @bug 8006775
* @bug 8006775 8027262
* @summary Import clauses cannot use annotations.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=AnnotatedImport.out -XDrawDiagnostics AnnotatedImport.java
*/

12
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedImport.out
View File

@ -1,7 +1,7 @@
AnnotatedImport.java:9:13: compiler.err.expected: token.identifier
AnnotatedImport.java:9:14: compiler.err.expected3: class, interface, enum
AnnotatedImport.java:10:7: compiler.err.expected: token.identifier
AnnotatedImport.java:10:10: compiler.err.expected: ';'
AnnotatedImport.java:11:18: compiler.err.expected: token.identifier
AnnotatedImport.java:11:19: compiler.err.expected3: class, interface, enum
AnnotatedImport.java:10:13: compiler.err.expected: token.identifier
AnnotatedImport.java:10:16: compiler.err.expected3: class, interface, enum
AnnotatedImport.java:11:7: compiler.err.expected: token.identifier
AnnotatedImport.java:11:11: compiler.err.expected3: class, interface, enum
AnnotatedImport.java:12:18: compiler.err.expected: token.identifier
AnnotatedImport.java:12:21: compiler.err.expected3: class, interface, enum
6 errors

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/AnnotatedPackage1.java
View File

@ -1,9 +1,8 @@
/*
* @test /nodynamiccopyright/
* @bug 8006775
* @bug 8006775 8027262
* @summary Package declarations cannot use annotations.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=AnnotatedPackage1.out -XDrawDiagnostics AnnotatedPackage1.java
*/

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:16: compiler.err.expected3: class, interface, enum
AnnotatedPackage1.java:9:17: compiler.err.expected3: class, interface, enum
2 errors

10
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.out
View File

@ -1,5 +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
CantAnnotatePackages.java:14:13: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotatePackages.java:19:18: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotatePackages.java:20:19: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotatePackages.java:21:24: compiler.err.cant.type.annotate.scoping.1: @TA
4 errors

20
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out
View File

@ -1,12 +1,14 @@
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:66:18: compiler.err.doesnt.exist: java.XXX
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:40:19: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:47:13: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:56:32: compiler.err.cant.type.annotate.scoping: @TA,@TA2
CantAnnotateScoping.java:61:19: compiler.err.cant.type.annotate.scoping.1: @DA
CantAnnotateScoping.java:70:19: compiler.err.cant.type.annotate.scoping.1: @TA
CantAnnotateScoping.java:61:11: compiler.err.annotation.type.not.applicable
CantAnnotateScoping.java:66:11: compiler.err.annotation.type.not.applicable
CantAnnotateScoping.java:42:39: compiler.err.cant.type.annotate.scoping: @TA,@DA,@TA2
CantAnnotateScoping.java:42:25: compiler.err.annotation.type.not.applicable
CantAnnotateScoping.java:44:38: compiler.err.cant.type.annotate.scoping: @TA,@DA
CantAnnotateScoping.java:44:43: compiler.err.cant.type.annotate.scoping: @TA,@DA
CantAnnotateScoping.java:44:34: compiler.err.annotation.type.not.applicable
11 errors
13 errors

121
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass.java
View File

@ -12,14 +12,49 @@ 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 {}
@Target(ElementType.TYPE_USE) @interface TA {}
@Target(ElementType.TYPE_USE) @interface TB1 {}
@Target(ElementType.TYPE_USE) @interface TB2 {}
@Target(ElementType.TYPE_USE) @interface TB3 {}
@Target(ElementType.TYPE_USE) @interface TB4 {}
@Target(ElementType.TYPE_USE) @interface TB5 {}
@Target(ElementType.TYPE_USE) @interface TB6 {}
@Target(ElementType.TYPE_USE) @interface TB7 {}
@Target(ElementType.TYPE_USE) @interface TB8 {}
@Target(ElementType.TYPE_USE) @interface TB9 {}
@Target(ElementType.TYPE_USE) @interface TB10 {}
@Target(ElementType.TYPE_USE) @interface TB11 {}
@Target(ElementType.TYPE_USE) @interface TB12 {}
@Target(ElementType.TYPE_USE) @interface TB13 {}
@Target(ElementType.TYPE_USE) @interface TB14 {}
@Target(ElementType.TYPE_USE) @interface TB15 {}
@Target(ElementType.TYPE_USE) @interface TB16 {}
@Target(ElementType.TYPE_USE) @interface TB17 {}
@Target(ElementType.TYPE_USE) @interface TB18 {}
@Target(ElementType.TYPE_USE) @interface TB19 {}
@Target(ElementType.TYPE_USE) @interface TB20 {}
@Target(ElementType.TYPE_USE) @interface TB21 {}
@Target(ElementType.TYPE_USE) @interface TB22 {}
@Target(ElementType.TYPE_USE) @interface TB23 {}
@Target(ElementType.TYPE_USE) @interface TB24 {}
@Target(ElementType.TYPE_USE) @interface TB25 {}
@Target(ElementType.TYPE_USE) @interface TB26 {}
@Target(ElementType.TYPE_USE) @interface TB27 {}
@Target(ElementType.TYPE_USE) @interface TB28 {}
@Target(ElementType.TYPE_USE) @interface TB29 {}
@Target(ElementType.TYPE_USE) @interface TB30 {}
@Target(ElementType.TYPE_USE) @interface TB31 {}
@Target(ElementType.TYPE_USE) @interface TB32 {}
@Target(ElementType.TYPE_USE) @interface TB33 {}
@Target(ElementType.TYPE_USE) @interface TB34 {}
@Target(ElementType.TYPE_USE) @interface TB35 {}
@Target(ElementType.TYPE_USE) @interface TB36 {}
@Target(ElementType.TYPE_USE) @interface TB37 {}
@Target(ElementType.TYPE_USE) @interface TB38 {}
@Target(ElementType.TYPE_USE) @interface TB39 {}
@Target(ElementType.TYPE_USE) @interface TB40 {}
@Target(ElementType.TYPE_USE) @interface TB41 {}
@Target(ElementType.TYPE_USE) @interface TC {}
class Outer {
class Inner {
@ -34,63 +69,63 @@ class Top {
// All combinations are OK
Top.@TB Outer f1;
@TB Outer.Inner f1a;
Top.@TB1 Outer f1;
@TB2 Outer.Inner f1a;
Outer. @TC Inner f1b;
@TB Outer. @TC Inner f1c;
@TB3 Outer. @TC Inner f1c;
@TA Top. @TB Outer f2;
@TA Top. @TB Outer.Inner f2a;
@TA Top. @TB4 Outer f2;
@TA Top. @TB5 Outer.Inner f2a;
@TA Top. Outer. @TC Inner f2b;
@TA Top. @TB Outer. @TC Inner f2c;
@TA Top. @TB6 Outer. @TC Inner f2c;
@TB Outer f1r() { return null; }
@TB Outer.Inner f1ra() { return null; }
@TB7 Outer f1r() { return null; }
@TB8 Outer.Inner f1ra() { return null; }
Outer. @TC Inner f1rb() { return null; }
@TB Outer. @TC Inner f1rc() { return null; }
@TB9 Outer. @TC Inner f1rc() { return null; }
void f1param(@TB Outer p,
@TB Outer.Inner p1,
void f1param(@TB41 Outer p,
@TB10 Outer.Inner p1,
Outer. @TC Inner p2,
@TB Outer. @TC Inner p3) { }
@TB11 Outer. @TC Inner p3) { }
void f1cast(Object o) {
Object l;
l = (@TB Outer) o;
l = (@TB Outer.Inner) o;
l = (@TB12 Outer) o;
l = (@TB13 Outer.Inner) o;
l = (Outer. @TC Inner) o;
l = (@TB Outer. @TC Inner) o;
l = (@TB14 Outer. @TC Inner) o;
}
List<@TB Outer> g1;
List<@TB Outer.Inner> g1a;
List<@TB15 Outer> g1;
List<@TB16 Outer.Inner> g1a;
List<Outer. @TC Inner> g1b;
List<@TB Outer. @TC Inner> g1c;
List<@TB17 Outer. @TC Inner> g1c;
List<@TA Top. @TB Outer> g2;
List<@TA Top. @TB Outer.Inner> g2a;
List<@TA Top. @TB18 Outer> g2;
List<@TA Top. @TB19 Outer.Inner> g2a;
List<@TA Top. Outer. @TC Inner> g2b;
List<@TA Top. @TB Outer. @TC Inner> g2c;
List<@TA Top. @TB20 Outer. @TC Inner> g2c;
List<@TB Outer> g1r() { return null; }
List<@TB Outer.Inner> g1ra() { return null; }
List<@TB21 Outer> g1r() { return null; }
List<@TB22 Outer.Inner> g1ra() { return null; }
List<Outer. @TC Inner> g1rb() { return null; }
List<@TB Outer. @TC Inner> g1rc() { return null; }
List<@TB23 Outer. @TC Inner> g1rc() { return null; }
void g1param(List<@TB Outer> p,
List<@TB Outer.Inner> p1,
void g1param(List<@TB24 Outer> p,
List<@TB25 Outer.Inner> p1,
List<Outer. @TC Inner> p2,
List<@TB Outer. @TC Inner> p3) { }
List<@TB26 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>();
l = new @TB27 ArrayList<@TB28 Outer>();
l = new @TB29 ArrayList<@TB30 Outer.Inner>();
l = new @TB31 HashMap<String, Outer. @TC Inner>();
l = new @TB32 HashMap<String, @TB33 Outer. Inner>();
l = new @TB34 HashMap<String, @TB35 Outer. @TC Inner>();
l = new @TB36 HashMap<String, @TA Top. Outer. @TC Inner>();
l = new @TB37 HashMap<String, @TA Top. @TB38 Outer. Inner>();
l = new @TB39 HashMap<String, @TA Top. @TB40 Outer. @TC Inner>();
}
}

125
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.out
View File

@ -1,65 +1,72 @@
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:52:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:53:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:55:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:56:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:60:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:61:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:62:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:64:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:65:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:66:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
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:79:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:80:14: 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:89:22: 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: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: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: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
CantAnnotateStaticClass2.java:93:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:120:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:121:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:128:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:129:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:131:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:133:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:134:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:135:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:137:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:138:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:139:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:141:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:142:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:143:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:149:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:150:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:157:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:158:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:165:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:167:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:169:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:171:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:105:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:107:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:112:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:114:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:184:40: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:186:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:187:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:192:40: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:194:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:195:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:199:38: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:200:38: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:200:49: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:201:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:202:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:202:55: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass2.java:203:55: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass2.java:204:52: compiler.err.cant.type.annotate.scoping: @Top.TA,@Top.TB,@Top.TC
71 errors

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.java
View File

@ -1,9 +1,8 @@
/*
* @test /nodynamiccopyright/
* @bug 8006733 8006775
* @bug 8006733 8006775 8027262
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore
* @compile/fail/ref=CantAnnotateStaticClass3.out -XDrawDiagnostics CantAnnotateStaticClass3.java
*/

157
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass3.out
View File

@ -1,83 +1,92 @@
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:52:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:53:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:54:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:56:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:57:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:57:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:58:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:58:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:59:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:59:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:61:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:62:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:63:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:65:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:65:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:66:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:66:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:67:12: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:67:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
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:79:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:80:14: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:81:14: 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:86:22: 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:90:22: 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
CantAnnotateStaticClass3.java:94:22: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:120:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:121:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:122:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:128:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:129:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:130:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:132:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:134:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:134:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:135:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:135:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:136:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:136:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:138:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:139:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:140:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:142:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:142:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:143:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:143:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:144:17: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:144:28: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:149:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:150:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:151:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:157:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:158:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:159:19: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:162:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:164:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:166:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:168:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:170:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:172:27: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:99:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:101:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:106:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:108:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:113:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:115:23: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:177:40: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:179:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:180:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:185:40: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:187:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:188:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:193:40: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:195:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:196:46: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:200:38: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:201:38: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:201:49: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:202:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:203:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:203:55: compiler.err.cant.type.annotate.scoping.1: @Top.TB
CantAnnotateStaticClass3.java:204:44: compiler.err.cant.type.annotate.scoping.1: @Top.TA
CantAnnotateStaticClass3.java:204:55: compiler.err.cant.type.annotate.scoping.1: @Top.TB
91 errors

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/DeclarationAnnotation.java
View File

@ -10,7 +10,7 @@ class DeclarationAnnotation {
Object e1 = new @DA int[5];
Object e2 = new @DA String[42];
Object e3 = new @DA Object();
Object ok = new @DA Object() { };
Object e4 = new @DA Object() { };
}
@interface DA { }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/DeclarationAnnotation.out
View File

@ -1,5 +1,5 @@
DeclarationAnnotation.java:13:21: compiler.err.annotation.type.not.applicable
DeclarationAnnotation.java:10:21: compiler.err.annotation.type.not.applicable
DeclarationAnnotation.java:11:21: compiler.err.annotation.type.not.applicable
DeclarationAnnotation.java:12:21: compiler.err.annotation.type.not.applicable
DeclarationAnnotation.java:13:21: compiler.err.annotation.type.not.applicable
4 errors

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/MissingAnnotationValue.java
View File

@ -5,10 +5,13 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue {
void test() {
String @A [] s;
}
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:10:12: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:12:12: compiler.err.annotation.missing.default.value: A, field
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/innertypeparams/MissingAnnotationValue.java
View File

@ -5,10 +5,13 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue {
void innermethod() {
class Inner<@A K> { }
}
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/innertypeparams/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:10:17: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:12:17: compiler.err.annotation.missing.default.value: A, field
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/newarray/MissingAnnotationValue.java
View File

@ -5,10 +5,13 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue {
void test() {
String[] a = new String @A [5];
}
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/newarray/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:10:29: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:12:29: compiler.err.annotation.missing.default.value: A, field
1 error

5
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/receiver/MissingAnnotationValue.java
View File

@ -5,8 +5,13 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
import static java.lang.annotation.RetentionPolicy.*;
import static java.lang.annotation.ElementType.*;
class MissingAnnotationValue {
void test(@A MissingAnnotationValue this) { }
}
@Target({TYPE_USE})
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/receiver/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:9:13: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:13:13: compiler.err.annotation.missing.default.value: A, field
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/typeArgs/MissingAnnotationValue.java
View File

@ -5,8 +5,11 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue<K> {
MissingAnnotationValue<@A String> l;
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/typeArgs/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:9:26: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:11:26: compiler.err.annotation.missing.default.value: A, field
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/typeparams/MissingAnnotationValue.java
View File

@ -5,7 +5,10 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue<@A K> {
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/typeparams/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:8:30: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:10:30: compiler.err.annotation.missing.default.value: A, field
1 error

3
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/wildcards/MissingAnnotationValue.java
View File

@ -5,8 +5,11 @@
* @author Mahmood Ali
* @compile/fail/ref=MissingAnnotationValue.out -XDrawDiagnostics MissingAnnotationValue.java
*/
import java.lang.annotation.*;
class MissingAnnotationValue<K> {
MissingAnnotationValue<@A ?> l;
}
@Target(ElementType.TYPE_USE)
@interface A { int field(); }

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/common/wildcards/MissingAnnotationValue.out
View File

@ -1,2 +1,2 @@
MissingAnnotationValue.java:9:26: compiler.err.annotation.missing.default.value: A, field
MissingAnnotationValue.java:11:26: compiler.err.annotation.missing.default.value: A, field
1 error

196
langtools/test/tools/javac/annotations/typeAnnotations/newlocations/AllLocations.java Normal file
View File

@ -0,0 +1,196 @@
/*
* Copyright (c) 2014, 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 8027262
* @summary Stress test for type annotatons
* @compile AllLocations.java
*/
import java.util.function.Function;
import java.lang.annotation.*;
import static java.lang.annotation.RetentionPolicy.*;
import static java.lang.annotation.ElementType.*;
import java.io.*;
import java.lang.ref.WeakReference;
public class AllLocations {
public class ParamStream<T> extends FileOutputStream {
public ParamStream(File f) throws FileNotFoundException { super(f); }
}
public class Inner<S> {
public Inner() {}
public <@A T> Inner(@B Object o) {}
public <@C T> Object g(Inner<@D S> this, Object @E [] o) {
return new @F int @G [5];
}
}
public <@H T extends @I Inner<@J ? extends @K String>> AllLocations(Object o) {}
public @L Object @M [] @N [] arr = new @O Object @P [5] @Q [5];
public Inner<@R ? extends @S Inner<@T ? extends @U Integer>> inner;
public Function func(@V AllLocations this) {
try (final ParamStream<@W Integer @X []> fs = new ParamStream<@Y Integer @Z []>(new File("testfile"))) {
return @AA AllLocations.Inner<@AB String>::<@AC Integer>new;
} catch(@AD Exception ex) {
return null;
}
}
public <@AE T extends @AF Inner<@AG Integer @AH []>> Function func2() {
arr[0][0] = new @AI Inner((@AJ Object) arr[0]);
return Ext.f((@AK Object) arr[0]) instanceof @AL Inner @AM [] @AN [] ?
@AO @AP Ext::<@AQ @AR Integer> f :
@AS @AT Ext::<@AU @AV Integer> f;
}
public Object func3(Object @AW [] arr) {
Inner<@AX ? extends @AY Inner<@AZ ? extends @BA Integer>> loc;
if (arr[0] instanceof @BB Inner @BC [] @BD [])
return this.<Inner<@BE Integer @BF []>> func4();
else
return new <@BG Inner<@BH Integer>> @BI Inner<@BJ Inner<@BK Integer>>(null);
}
public <@BL T extends @BO Inner<@BP Integer @BQ []>>
@BR Inner<@BS Inner<@BT String>> func4() {
return (@BU Inner<@BV Inner<@BW String>>)
new <@BX Inner<@BY Integer>> @BZ Inner<@CA Inner<@CB String>>(null) {};
}
{ Inner<@CC ? extends @CD Inner<@CE ? extends @CF Integer>> loc =
new @CG Inner<@CH Inner<@CI Integer>>() {};
Ext.func(Ext.func(@CJ WeakReference::new));
Ext.func(Ext.func(@CK Ext::<@CL Integer>f));
Ext.func((@CM Object a) -> { @CN Object b = a; return b; });
}
}
class Ext {
public static <@CO T> Object f(Object o) {
return null;
}
public static Function func(Function f) { return f; }
}
@Retention(RUNTIME) @Target({TYPE_USE}) @interface A { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface B { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface C { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface D { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface E { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface F { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface G { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface H { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface I { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface J { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface K { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface L { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface M { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface N { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface O { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface P { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface Q { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface R { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface S { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface T { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface U { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface V { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface W { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface X { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface Y { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface Z { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AA { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AB { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AC { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AD { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AE { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AF { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AG { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AH { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AI { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AJ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AK { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AL { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AM { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AN { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AO { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AP { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AQ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AR { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AS { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AT { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AU { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AV { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AW { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AX { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AY { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface AZ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BA { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BB { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BC { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BD { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BE { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BF { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BG { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BH { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BI { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BJ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BK { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BL { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BM { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BN { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BO { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BP { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BQ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BR { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BS { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BT { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BU { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BV { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BW { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BX { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BY { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface BZ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CA { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CB { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CC { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CD { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CE { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CF { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CG { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CH { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CI { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CJ { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CK { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CL { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CM { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CN { }
@Retention(RUNTIME) @Target({TYPE_USE}) @interface CO { }

44
langtools/test/tools/javac/annotations/typeAnnotations/newlocations/Expressions.java
View File

@ -52,28 +52,40 @@ class Expressions {
}
void objectCreationArray() {
Object a1 = new @A String [] [] { };
Object a2 = new @A String [1] [];
Object a3 = new @A String [1] [2];
Object a1 = new @C String [] [] { };
Object a2 = new @D String [1] [];
Object a3 = new @E String [1] [2];
Object b1 = new @A String @B(0) [] [] { };
Object b2 = new @A String @B(0) [1] [];
Object b3 = new @A String @B(0) [1] [2];
Object b1 = new @F String @B(1) [] [] { };
Object b2 = new @G String @B(2) [1] [];
Object b3 = new @H String @B(3) [1] [2];
Object c1 = new @A String [] @B(0) [] { };
Object c2 = new @A String [1] @B(0) [];
Object c3 = new @A String [1] @B(0) [2];
Object c1 = new @I String [] @B(4) [] { };
Object c2 = new @J String [1] @B(5) [];
Object c3 = new @K String [1] @B(6) [2];
Object d1 = new @A String @B(0) [] @B(0) [] { };
Object d2 = new @A String @B(0) [1] @B(0) [];
Object d3 = new @A String @B(0) [1] @B(0) [2];
Object d1 = new @L String @B(7) [] @B(8) [] { };
Object d2 = new @M String @B(9) [1] @B(10) [];
Object d3 = new @N String @B(11) [1] @B(12) [2];
Object rand = new @A String @B(value = 0) [1] @B(value = 0) [2];
Object rand = new @O String @B(value = 13) [1] @B(value = 14) [2];
}
}
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface A { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface C { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface D { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface E { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface F { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface G { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface H { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface I { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface J { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface K { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface L { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface M { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface N { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) @interface O { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@interface A { }
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@interface B { int value(); }
@interface B { int value(); }

1
langtools/test/tools/javac/annotations/typeAnnotations/newlocations/NestedTypes.java
View File

@ -128,6 +128,7 @@ class Test1 {
MyList<Outer . @Cv("Data") Static> f9;
// Illegal:
// MyList<@A Outer . @Cv("Data") Static> f9;
}
class Test2 {

6
langtools/test/tools/javac/annotations/typeAnnotations/newlocations/RepeatingTypeAnnotations.out
View File

@ -17,12 +17,12 @@ RepeatingTypeAnnotations.java:89:18: compiler.err.duplicate.annotation.missing.c
RepeatingTypeAnnotations.java:89:33: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:93:19: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:93:35: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:97:34: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:97:19: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:26: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:97:34: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:37: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:72: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:26: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:56: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
RepeatingTypeAnnotations.java:101:72: compiler.err.duplicate.annotation.missing.container: TA, java.lang.annotation.Repeatable
- compiler.note.unchecked.filename: RepeatingTypeAnnotations.java
- compiler.note.unchecked.recompile
25 errors

2
langtools/test/tools/javac/annotations/typeAnnotations/referenceinfos/Fields.java
View File

@ -30,7 +30,6 @@ import static com.sun.tools.classfile.TypeAnnotation.TargetType.*;
* @run main Driver Fields
*/
public class Fields {
// field types
@TADescription(annotation = "TA", type = FIELD)
public String fieldAsPrimitive() {
@ -124,5 +123,4 @@ public class Fields {
public String staticFieldAsParametrized() {
return "static @TA Map<@TB String, @TC List<@TD String>> test;";
}
}

13
langtools/test/tools/javac/processing/model/element/TestAnonClassNames.java
View File

@ -96,9 +96,10 @@ public class TestAnonClassNames {
List<String> names = new ArrayList<String>();
for(Class<?> clazz : classes) {
String name = clazz.getName();
System.out.format("%s is %s%n",
clazz.getName(),
clazz.getAnnotation(Nesting.class).value());
Nesting annotation = clazz.getAnnotation(Nesting.class);
NestingKind expected = annotation == null ?
NestingKind.ANONYMOUS : annotation.value();
System.out.format("%s is %s%n", name, expected);
testClassName(name);
names.add(name);
}
@ -186,7 +187,11 @@ class ClassNameProber extends JavacTestingAbstractProcessor {
typeElt.getKind().toString(),
nestingKind.toString());
if (typeElt.getAnnotation(Nesting.class).value() != nestingKind) {
Nesting annotation = typeElt.getAnnotation(Nesting.class);
NestingKind expected = annotation == null ?
NestingKind.ANONYMOUS : annotation.value();
if (expected != nestingKind) {
throw new RuntimeException("Mismatch of expected and reported nesting kind.");
}
}

4
langtools/test/tools/javac/tree/TreePosTest.java
View File

@ -367,7 +367,9 @@ public class TreePosTest {
// and because of inconsistent nesting of left and right of
// array declarations:
// e.g. int[][] a = new int[2][];
if (!(encl.tag == REFERENCE && self.tag == ANNOTATED_TYPE)) {
check("encl.start <= start", encl, self, encl.start <= self.start);
}
check("start <= pos", encl, self, self.start <= self.pos);
if (!( (self.tag == TYPEARRAY ||
isAnnotatedArray(self.tree))
@ -377,6 +379,8 @@ public class TreePosTest {
isAnnotatedArray(encl.tree))
||
encl.tag == ANNOTATED_TYPE && self.tag == SELECT
||
encl.tag == REFERENCE && self.tag == ANNOTATED_TYPE
)) {
check("encl.pos <= start || end <= encl.pos",
encl, self, encl.pos <= self.start || self.end <= encl.pos);

2
langtools/test/tools/javac/warnings/6747671/T6747671.out
View File

@ -8,5 +8,5 @@ T6747671.java:32:9: compiler.warn.raw.class.use: T6747671.A, T6747671<E>.A<X>
T6747671.java:32:20: compiler.warn.raw.class.use: T6747671.A, T6747671<E>.A<X>
T6747671.java:33:16: compiler.warn.raw.class.use: T6747671.A.Z, T6747671<E>.A<X>.Z<Y>
T6747671.java:36:9: compiler.warn.raw.class.use: @T6747671.TA T6747671.B, T6747671.B<X>
T6747671.java:36:27: compiler.warn.raw.class.use: T6747671.B, T6747671.B<X>
T6747671.java:36:27: compiler.warn.raw.class.use: @T6747671.TA T6747671.B, T6747671.B<X>
11 warnings

6
langtools/test/tools/javac/warnings/suppress/T6480588.out
View File

@ -1,6 +1,6 @@
T6480588.java:11:2: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
T6480588.java:12:24: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:12:51: compiler.warn.has.been.deprecated: DeprecatedInterface, compiler.misc.unnamed.package
T6480588.java:11:2: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
T6480588.java:14:12: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:14:65: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:13:6: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
@ -12,7 +12,7 @@ T6480588.java:17:35: compiler.warn.has.been.deprecated: DeprecatedClass, compile
T6480588.java:26:5: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:25:6: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
T6480588.java:26:33: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:28:6: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
T6480588.java:29:25: compiler.warn.has.been.deprecated: DeprecatedClass, compiler.misc.unnamed.package
T6480588.java:29:52: compiler.warn.has.been.deprecated: DeprecatedInterface, compiler.misc.unnamed.package
T6480588.java:28:6: compiler.warn.has.been.deprecated: DeprecatedAnnotation, compiler.misc.unnamed.package
17 warnings
17 warnings

11
langtools/test/tools/javac/warnings/suppress/TypeAnnotations.out
View File

@ -5,28 +5,20 @@ TypeAnnotations.java:14:61: compiler.warn.has.been.deprecated: TA, compiler.misc
TypeAnnotations.java:14:13: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:14:44: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:14:33: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:23:29: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:23:18: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:16:14: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:17:58: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:17:14: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:17:58: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:20:10: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:21:54: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:21:10: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:21:54: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:23:18: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:23:29: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:28:14: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:29:58: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:29:14: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:29:58: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:32:10: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:33:54: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:33:10: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:33:54: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:35:46: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:35:35: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:35:21: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:35:10: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:35:35: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
@ -35,7 +27,6 @@ TypeAnnotations.java:38:17: compiler.warn.has.been.deprecated: TA, compiler.misc
TypeAnnotations.java:38:6: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:38:43: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:38:32: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:38:32: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:42:40: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
TypeAnnotations.java:42:62: compiler.warn.has.been.deprecated: TA, compiler.misc.unnamed.package
40 warnings
31 warnings

147
langtools/test/tools/javap/output/RepeatingTypeAnnotations.java
View File

@ -245,11 +245,11 @@ public class RepeatingTypeAnnotations extends Tester {
" @A @A @A String ls = (@B @B @B String) o;",
" }");
verify("RuntimeInvisibleTypeAnnotations",
"0: #34(#35=[@#36(),@#36(),@#36()]): CAST, offset=4, type_index=0",
"1: #37(#35=[@#38(),@#38(),@#38()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #34(#35=[@#36(),@#36(),@#36()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #37(#35=[@#38(),@#38(),@#38()]): CAST, offset=4, type_index=0",
"RuntimeInvisibleTypeAnnotations",
"0: #37(#35=[@#38(),@#38(),@#38()]): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #38(): METHOD_FORMAL_PARAMETER, param_index=1");
"0: #36(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #34(#35=[@#36(),@#36(),@#36()]): METHOD_FORMAL_PARAMETER, param_index=0");
}
}
@ -261,15 +261,15 @@ public class RepeatingTypeAnnotations extends Tester {
" @A @A @B String ls = (@B @A @B String) o;",
" }");
verify("RuntimeInvisibleTypeAnnotations",
"0: #34(#35=[@#36(),@#36()]): CAST, offset=4, type_index=0",
"1: #37(): CAST, offset=4, type_index=0",
"2: #38(#35=[@#37(),@#37()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"3: #36(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #34(#35=[@#36(),@#36()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #37(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"2: #38(#35=[@#37(),@#37()]): CAST, offset=4, type_index=0",
"3: #36(): CAST, offset=4, type_index=0",
"RuntimeInvisibleTypeAnnotations",
"0: #38(#35=[@#37(),@#37()]): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #36(): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #37(): METHOD_FORMAL_PARAMETER, param_index=1",
"3: #36(): METHOD_FORMAL_PARAMETER, param_index=1");
"0: #36(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #37(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #34(#35=[@#36(),@#36()]): METHOD_FORMAL_PARAMETER, param_index=0",
"3: #37(): METHOD_FORMAL_PARAMETER, param_index=0");
}
}
@ -282,14 +282,14 @@ public class RepeatingTypeAnnotations extends Tester {
" }");
verify("RuntimeVisibleTypeAnnotations",
"RuntimeInvisibleTypeAnnotations",
"0: #34(): CAST, offset=4, type_index=0",
"1: #35(#36=[@#34(),@#34()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #38(#36=[@#39(),@#39()]): CAST, offset=4, type_index=0",
"1: #39(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #35(#36=[@#34(),@#34()]): METHOD_FORMAL_PARAMETER, param_index=0",
"0: #39(): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #39(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #40(): METHOD_FORMAL_PARAMETER, param_index=1");
"0: #34(#35=[@#36(),@#36()]): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #36(): CAST, offset=4, type_index=0",
"0: #38(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #39(#35=[@#38(),@#38()]): CAST, offset=4, type_index=0",
"0: #34(#35=[@#36(),@#36()]): METHOD_FORMAL_PARAMETER, param_index=0",
"0: #38(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #40(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #38(): METHOD_FORMAL_PARAMETER, param_index=0");
}
}
@ -301,13 +301,13 @@ public class RepeatingTypeAnnotations extends Tester {
" @A @B @C String ls = (@C @A @B String) o;",
" }");
verify("RuntimeVisibleTypeAnnotations",
"0: #34(): CAST, offset=4, type_index=0",
"1: #34(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #34(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #34(): CAST, offset=4, type_index=0",
"RuntimeInvisibleTypeAnnotations",
"0: #36(): CAST, offset=4, type_index=0",
"1: #37(): CAST, offset=4, type_index=0",
"2: #36(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"3: #37(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"0: #36(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"1: #37(): LOCAL_VARIABLE, {start_pc=10, length=1, index=5}",
"2: #36(): CAST, offset=4, type_index=0",
"3: #37(): CAST, offset=4, type_index=0",
"0: #34(): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #34(): METHOD_FORMAL_PARAMETER, param_index=1",
"0: #36(): METHOD_FORMAL_PARAMETER, param_index=0",
@ -325,13 +325,14 @@ public class RepeatingTypeAnnotations extends Tester {
" return (@A @A @A String) o;",
" }");
verify("RuntimeInvisibleTypeAnnotations",
"0: #36(#37=[@#38(),@#38(),@#38()]): CAST, offset=0, type_index=0",
"1: #39(#37=[@#40(),@#40(),@#40()]): CAST, offset=6, type_index=0",
"2: #39(#37=[@#40(),@#40(),@#40()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #36(#37=[@#38(),@#38(),@#38()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #39(#37=[@#40(),@#40(),@#40()]): CAST, offset=0, type_index=0",
"2: #36(#37=[@#38(),@#38(),@#38()]): CAST, offset=6, type_index=0",
"RuntimeInvisibleTypeAnnotations",
"0: #39(#37=[@#40(),@#40(),@#40()]): METHOD_RETURN",
"1: #39(#37=[@#40(),@#40(),@#40()]): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #40(): METHOD_FORMAL_PARAMETER, param_index=1");
"0: #38(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #36(#37=[@#38(),@#38(),@#38()]): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #36(#37=[@#38(),@#38(),@#38()]): METHOD_RETURN"
);
}
}
@ -345,19 +346,19 @@ public class RepeatingTypeAnnotations extends Tester {
" }");
verify(
"RuntimeInvisibleTypeAnnotations:",
"0: #36(#37=[@#38(),@#38()]): CAST, offset=0, type_index=0",
"1: #39(): CAST, offset=0, type_index=0",
"2: #39(): CAST, offset=6, type_index=0",
"3: #36(#37=[@#38(),@#38()]): CAST, offset=6, type_index=0",
"4: #40(#37=[@#39(),@#39()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"5: #38(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #36(#37=[@#38(),@#38()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #39(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"2: #40(#37=[@#39(),@#39()]): CAST, offset=0, type_index=0",
"3: #38(): CAST, offset=0, type_index=0",
"4: #38(): CAST, offset=6, type_index=0",
"5: #40(#37=[@#39(),@#39()]): CAST, offset=6, type_index=0",
"RuntimeInvisibleTypeAnnotations:",
"0: #39(): METHOD_RETURN",
"1: #36(#37=[@#38(),@#38()]): METHOD_RETURN",
"2: #40(#37=[@#39(),@#39()]): METHOD_FORMAL_PARAMETER, param_index=0",
"3: #38(): METHOD_FORMAL_PARAMETER, param_index=0",
"4: #39(): METHOD_FORMAL_PARAMETER, param_index=1",
"5: #38(): METHOD_FORMAL_PARAMETER, param_index=1"
"0: #38(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #39(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #36(#37=[@#38(),@#38()]): METHOD_FORMAL_PARAMETER, param_index=0",
"3: #39(): METHOD_FORMAL_PARAMETER, param_index=0",
"4: #38(): METHOD_RETURN",
"5: #40(#37=[@#39(),@#39()]): METHOD_RETURN"
);
}
}
@ -372,21 +373,21 @@ public class RepeatingTypeAnnotations extends Tester {
" }");
verify(
"RuntimeVisibleTypeAnnotations:",
"0: #36(): CAST, offset=0, type_index=0",
"1: #36(): CAST, offset=6, type_index=0",
"2: #37(#38=[@#36(),@#36()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #36(#37=[@#38(),@#38()]): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #38(): CAST, offset=0, type_index=0",
"2: #38(): CAST, offset=6, type_index=0",
"RuntimeInvisibleTypeAnnotations:",
"0: #40(#38=[@#41(),@#41()]): CAST, offset=0, type_index=0",
"1: #42(#38=[@#43(),@#43()]): CAST, offset=6, type_index=0",
"2: #41(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #40(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #41(#37=[@#40(),@#40()]): CAST, offset=0, type_index=0",
"2: #42(#37=[@#43(),@#43()]): CAST, offset=6, type_index=0",
"RuntimeVisibleTypeAnnotations:",
"0: #36(): METHOD_RETURN",
"1: #37(#38=[@#36(),@#36()]): METHOD_FORMAL_PARAMETER, param_index=0",
"0: #36(#37=[@#38(),@#38()]): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #38(): METHOD_RETURN",
"RuntimeInvisibleTypeAnnotations:",
"0: #40(#38=[@#41(),@#41()]): METHOD_RETURN",
"1: #41(): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #41(): METHOD_FORMAL_PARAMETER, param_index=1",
"3: #43(): METHOD_FORMAL_PARAMETER, param_index=1"
"0: #40(): METHOD_FORMAL_PARAMETER, param_index=1",
"1: #43(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #40(): METHOD_FORMAL_PARAMETER, param_index=0",
"3: #41(#37=[@#40(),@#40()]): METHOD_RETURN"
);
}
}
@ -401,26 +402,26 @@ public class RepeatingTypeAnnotations extends Tester {
" }");
verify(
"RuntimeVisibleTypeAnnotations:",
"0: #36(): CAST, offset=0, type_index=0",
"1: #36(): CAST, offset=6, type_index=0",
"2: #36(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #36(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #36(): CAST, offset=0, type_index=0",
"2: #36(): CAST, offset=6, type_index=0",
"RuntimeInvisibleTypeAnnotations:",
"0: #38(): CAST, offset=0, type_index=0",
"1: #39(): CAST, offset=0, type_index=0",
"2: #39(): CAST, offset=6, type_index=0",
"3: #38(): CAST, offset=6, type_index=0",
"4: #38(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"5: #39(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"0: #38(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"1: #39(): LOCAL_VARIABLE, {start_pc=6, length=5, index=5}",
"2: #38(): CAST, offset=0, type_index=0",
"3: #39(): CAST, offset=0, type_index=0",
"4: #39(): CAST, offset=6, type_index=0",
"5: #38(): CAST, offset=6, type_index=0",
"RuntimeVisibleTypeAnnotations:",
"0: #36(): METHOD_RETURN",
"1: #36(): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #36(): METHOD_FORMAL_PARAMETER, param_index=1",
"0: #36(): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #36(): METHOD_FORMAL_PARAMETER, param_index=1",
"2: #36(): METHOD_RETURN",
"RuntimeInvisibleTypeAnnotations:",
"0: #38(): METHOD_RETURN",
"1: #39(): METHOD_RETURN",
"2: #38(): METHOD_FORMAL_PARAMETER, param_index=0",
"3: #39(): METHOD_FORMAL_PARAMETER, param_index=0",
"4: #38(): METHOD_FORMAL_PARAMETER, param_index=1"
"0: #38(): METHOD_FORMAL_PARAMETER, param_index=0",
"1: #39(): METHOD_FORMAL_PARAMETER, param_index=0",
"2: #38(): METHOD_FORMAL_PARAMETER, param_index=1",
"3: #38(): METHOD_RETURN",
"4: #39(): METHOD_RETURN"
);
}
}