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

Merge

Browse Source
This commit is contained in:
Lana Steuck 2014-09-10 19:38:20 -07:00
commit e3fe6d0c95
76 changed files with 2372 additions and 2879 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -151,7 +151,7 @@ public abstract class Attribute implements AnnotationValue {
* access this attribute.
*/
public final List<Pair<MethodSymbol,Attribute>> values;
public final TypeAnnotationPosition position;
public TypeAnnotationPosition position;
private boolean synthesized = false;
@ -179,9 +179,53 @@ 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); }
/**
@ -250,12 +294,6 @@ 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/jdk.compiler/share/classes/com/sun/tools/javac/code/TargetType.java
View File

@ -107,7 +107,10 @@ 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);
METHOD_REFERENCE_TYPE_ARGUMENT(0x4B, true),
/** For annotations with an unknown target. */
UNKNOWN(0xFF);
private static final int MAXIMUM_TARGET_TYPE_VALUE = 0x4B;
@ -147,15 +150,26 @@ 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];

18
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java
View File

@ -256,6 +256,9 @@ public class TypeAnnotationPosition {
case METHOD_RETURN:
case FIELD:
break;
case UNKNOWN:
sb.append(", position UNKNOWN!");
break;
default:
Assert.error("Unknown target type: " + type);
}
@ -658,11 +661,10 @@ 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,
type_index, Integer.MIN_VALUE,
Integer.MIN_VALUE, Integer.MIN_VALUE,
location);
}
@ -675,7 +677,7 @@ public class TypeAnnotationPosition {
public static TypeAnnotationPosition
exceptionParameter(final JCLambda onLambda,
final int pos) {
return exceptionParameter(emptyPath, onLambda, Integer.MIN_VALUE, pos);
return exceptionParameter(emptyPath, onLambda, pos);
}
/**
@ -685,7 +687,7 @@ public class TypeAnnotationPosition {
*/
public static TypeAnnotationPosition
exceptionParameter(final List<TypePathEntry> location) {
return exceptionParameter(location, null, Integer.MIN_VALUE, -1);
return exceptionParameter(location, null, -1);
}
@ -1199,4 +1201,12 @@ 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/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotations.java Normal file
View File

File diff suppressed because it is too large Load Diff

2001
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Annotate.java
View File

File diff suppressed because it is too large Load Diff

539
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
View File

@ -94,6 +94,7 @@ public class Attr extends JCTree.Visitor {
final Types types;
final JCDiagnostic.Factory diags;
final Annotate annotate;
final TypeAnnotations typeAnnotations;
final DeferredLintHandler deferredLintHandler;
final TypeEnvs typeEnvs;
final Dependencies dependencies;
@ -124,6 +125,7 @@ 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);
typeEnvs = TypeEnvs.instance(context);
dependencies = Dependencies.instance(context);
@ -372,7 +374,8 @@ 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));
}
@ -572,8 +575,7 @@ 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
@ -585,7 +587,6 @@ 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;
@ -600,7 +601,6 @@ 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);
}
@ -669,8 +669,7 @@ 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());
@ -705,7 +704,7 @@ public class Attr extends JCTree.Visitor {
* @param type The expected type, or null
* @see VarSymbol#setLazyConstValue
*/
public Object attribLazyConstantValue(final Env<AttrContext> env,
public Object attribLazyConstantValue(Env<AttrContext> env,
JCVariableDecl variable,
Type type) {
@ -824,7 +823,6 @@ public class Attr extends JCTree.Visitor {
c.flags_field |= NOOUTERTHIS;
}
attribClass(tree.pos(), c);
result = tree.type = c.type;
}
}
@ -867,9 +865,9 @@ public class Attr extends JCTree.Visitor {
ClassSymbol owner = env.enclClass.sym;
if ((owner.flags() & ANNOTATION) != 0 &&
tree.params.nonEmpty())
tree.params.nonEmpty())
log.error(tree.params.head.pos(),
"intf.annotation.members.cant.have.params");
"intf.annotation.members.cant.have.params");
// Attribute all value parameters.
for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
@ -943,91 +941,56 @@ public class Attr extends JCTree.Visitor {
if (tree.name == names.init && owner.type != syms.objectType) {
JCBlock body = tree.body;
if (body.stats.isEmpty() ||
!TreeInfo.isSelfCall(body.stats.head)) {
!TreeInfo.isSelfCall(body.stats.head)) {
body.stats = body.stats.
prepend(memberEnter.SuperCall(make.at(body.pos),
List.<Type>nil(),
List.<JCVariableDecl>nil(),
false));
prepend(memberEnter.SuperCall(make.at(body.pos),
List.<Type>nil(),
List.<JCVariableDecl>nil(),
false));
} else if ((env.enclClass.sym.flags() & ENUM) != 0 &&
(tree.mods.flags & GENERATEDCONSTR) == 0 &&
TreeInfo.isSuperCall(body.stats.head)) {
(tree.mods.flags & GENERATEDCONSTR) == 0 &&
TreeInfo.isSuperCall(body.stats.head)) {
// enum constructors are not allowed to call super
// directly, so make sure there aren't any super calls
// in enum constructors, except in the compiler
// generated one.
log.error(tree.body.stats.head.pos(),
"call.to.super.not.allowed.in.enum.ctor",
env.enclClass.sym);
"call.to.super.not.allowed.in.enum.ctor",
env.enclClass.sym);
}
}
// Attribute all type annotations in the body
annotate.annotateTypeLater(tree.body, localEnv, m, null);
annotate.flush();
// Attribute method body.
attribStat(tree.body, localEnv);
}
localEnv.info.scope.leave();
result = tree.type = m.type;
}
finally {
} finally {
chk.setLint(prevLint);
chk.setMethod(prevMethod);
}
}
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);
}
}
default:
// The default case is to treat any declaration as a local
// variable.
return annotate.localVarCreator(tree.pos);
}
}
public void visitVarDef(final JCVariableDecl tree) {
public void visitVarDef(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, getVarCreator(tree));
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();
}
}
@ -1086,6 +1049,9 @@ public class Attr extends JCTree.Visitor {
env.dup(tree, env.info.dup(env.info.scope.dupUnshared(fakeOwner)));
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();
attribStats(tree.stats, localEnv);
{
@ -1449,21 +1415,17 @@ public class Attr extends JCTree.Visitor {
isBooleanOrNumeric(env, condTree.falsepart);
case APPLY:
JCMethodInvocation speculativeMethodTree =
(JCMethodInvocation)deferredAttr.attribSpeculative(tree, env, unknownExprInfo,
annotate.noCreator);
(JCMethodInvocation)deferredAttr.attribSpeculative(tree, env, unknownExprInfo);
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,
annotate.newObjCreator(tree.pos));
(JCExpression)deferredAttr.attribSpeculative(className, env, unknownTypeInfo);
return types.unboxedTypeOrType(speculativeNewClassTree.type).isPrimitive();
default:
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo, annotate.noCreator).type;
Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo).type;
speculativeType = types.unboxedTypeOrType(speculativeType);
return speculativeType.isPrimitive();
}
@ -1724,28 +1686,7 @@ public class Attr extends JCTree.Visitor {
// Attribute arguments, yielding list of argument types.
attribArgs(tree.args, localEnv, argtypesBuf);
argtypes = argtypesBuf.toList();
// 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());
typeargtypes = attribTypes(tree.typeargs, localEnv);
// Variable `site' points to the class in which the called
// constructor is defined.
@ -1818,27 +1759,7 @@ public class Attr extends JCTree.Visitor {
// Attribute the arguments, yielding list of argument types, ...
int kind = attribArgs(tree.args, localEnv, argtypesBuf);
argtypes = argtypesBuf.toList();
// 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();
typeargtypes = attribAnyTypes(tree.typeargs, localEnv);
// ... and attribute the method using as a prototype a methodtype
// whose formal argument types is exactly the list of actual
@ -1863,7 +1784,6 @@ 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
@ -1935,12 +1855,14 @@ 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
@ -1962,12 +1884,11 @@ public class Attr extends JCTree.Visitor {
EndPosTable endPosTable = this.env.toplevel.endPositions;
endPosTable.storeEnd(clazzid1, tree.getEndPosition(endPosTable));
if (annoclazzid != null) {
JCAnnotatedType annoType = annoclazzid;
List<JCAnnotation> annos = annoclazzid.annotations;
if (clazz.hasTag(TYPEAPPLY)) {
if (clazz.hasTag(ANNOTATED_TYPE)) {
JCAnnotatedType annoType = (JCAnnotatedType) clazz;
List<JCAnnotation> annos = annoType.annotations;
if (annoType.underlyingType.hasTag(TYPEAPPLY)) {
clazzid1 = make.at(tree.pos).
TypeApply(clazzid1,
((JCTypeApply) clazz).arguments);
@ -1984,32 +1905,12 @@ 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.
clazztype = TreeInfo.isEnumInit(env.tree) ?
Type 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) {
@ -2038,29 +1939,7 @@ 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;
// 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());
List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
// If we have made no mistakes in the class type...
if (clazztype.hasTag(CLASS)) {
@ -2242,9 +2121,7 @@ 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,
annotate.newObjCreator(tree.pos)).type;
Type inferred = deferredAttr.attribSpeculative(tree, env, findDiamondResult).type;
Type polyPt = allowPoly ?
syms.objectType :
clazztype;
@ -2306,20 +2183,8 @@ 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) {
@ -2340,7 +2205,6 @@ 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,
@ -2737,8 +2601,6 @@ 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
@ -2749,20 +2611,9 @@ 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
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();
}
Type exprType = attribTree(that.expr, env, memberReferenceQualifierResult(that));
if (that.getMode() == JCMemberReference.ReferenceMode.NEW) {
exprType = chk.checkConstructorRefType(that.expr, exprType);
@ -2792,24 +2643,7 @@ 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;
@ -3192,15 +3026,7 @@ public class Attr extends JCTree.Visitor {
}
public void visitTypeCast(final JCTypeCast tree) {
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();
}
Type clazztype = attribType(tree.clazz, env);
chk.validate(tree.clazz, env, false);
//a fresh environment is required for 292 inference to work properly ---
//see Infer.instantiatePolymorphicSignatureInstance()
@ -3233,16 +3059,7 @@ public class Attr extends JCTree.Visitor {
public void visitTypeTest(JCInstanceOf tree) {
Type exprtype = chk.checkNullOrRefType(
tree.expr.pos(), attribExpr(tree.expr, 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();
}
Type clazztype = attribType(tree.clazz, env);
if (!clazztype.hasTag(TYPEVAR)) {
clazztype = chk.checkClassOrArrayType(tree.clazz.pos(), clazztype);
}
@ -3371,12 +3188,9 @@ public class Attr extends JCTree.Visitor {
if ((pkind() & (PCK | TYP)) == 0)
site = capture(site); // Capture field access
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
if (skind == TYP) {
Type elt = site;
while (elt.hasTag(ARRAY))
elt = ((ArrayType)elt).elemtype;
if (elt.hasTag(TYPEVAR)) {
@ -4224,13 +4038,8 @@ 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 = attribTree(tree.getUnderlyingType(), env,
resultInfo);
Type underlyingType = attribType(tree.getUnderlyingType(), env);
this.attribAnnotationTypes(tree.annotations, env);
annotateType(tree, tree.annotations);
result = tree.type = underlyingType;
@ -4249,10 +4058,8 @@ 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);
}
}
});
}
@ -4503,6 +4310,13 @@ 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) {
@ -4581,6 +4395,233 @@ 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/jdk.compiler/share/classes/com/sun/tools/javac/comp/AttrContext.java
View File

@ -59,11 +59,6 @@ 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;
@ -100,7 +95,6 @@ public class AttrContext {
info.returnResult = returnResult;
info.defaultSuperCallSite = defaultSuperCallSite;
info.isSerializable = isSerializable;
info.isSpeculative = isSpeculative;
return info;
}

51
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/DeferredAttr.java
View File

@ -25,7 +25,6 @@
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.*;
@ -78,7 +77,6 @@ public class DeferredAttr extends JCTree.Visitor {
final Types types;
final Flow flow;
final Names names;
final Annotate annotate;
final TypeEnvs typeEnvs;
public static DeferredAttr instance(Context context) {
@ -103,7 +101,6 @@ 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);
typeEnvs = TypeEnvs.instance(context);
emptyDeferredAttrContext =
new DeferredAttrContext(AttrMode.CHECK, null, MethodResolutionPhase.BOX, infer.emptyContext, null, null) {
@ -139,8 +136,7 @@ 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);
@ -284,18 +280,12 @@ 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,
annotate.noCreator);
JCTree speculativeTree = attribSpeculative(dt.tree, dt.env, resultInfo);
dt.speculativeCache.put(speculativeTree, resultInfo);
return speculativeTree.type;
case CHECK:
Assert.check(dt.mode != null);
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;
return attr.attribTree(dt.tree, dt.env, resultInfo);
}
Assert.error();
return null;
@ -372,13 +362,9 @@ 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,
Annotate.PositionCreator creator) {
JCTree attribSpeculative(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {
final JCTree newTree = new TreeCopier<>(make).copy(tree);
Env<AttrContext> speculativeEnv = env.dup(newTree, env.info.dup(env.info.scope.dupUnshared(env.info.scope.owner)));
speculativeEnv.info.isSpeculative = true;
Log.DeferredDiagnosticHandler deferredDiagnosticHandler =
new Log.DeferredDiagnosticHandler(log, new Filter<JCDiagnostic>() {
public boolean accepts(final JCDiagnostic d) {
@ -401,9 +387,6 @@ 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 {
@ -771,11 +754,8 @@ 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),
annotate.methodRefCreator(tree.pos));
JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
attr.memberReferenceQualifierResult(tree));
ListBuffer<Type> argtypes = new ListBuffer<>();
for (Type t : types.findDescriptorType(pt).getParameterTypes()) {
argtypes.append(Type.noType);
@ -1197,11 +1177,8 @@ 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),
annotate.methodRefCreator(tree.pos));
JCExpression exprTree = (JCExpression)attribSpeculative(tree.getQualifierExpression(), localEnv,
attr.memberReferenceQualifierResult(tree));
JCMemberReference mref2 = new TreeCopier<Void>(make).copy(tree);
mref2.expr = exprTree;
Symbol res =
@ -1345,12 +1322,18 @@ public class DeferredAttr extends JCTree.Visitor {
return null;
site = resolvedReturnType.type;
} else {
site = attribSpeculative(rec, env, attr.unknownTypeExprInfo, annotate.noCreator).type;
site = attribSpeculative(rec, env, attr.unknownTypeExprInfo).type;
}
} else {
site = env.enclClass.sym.type;
}
while (site.hasTag(TYPEVAR)) {
site = site.getUpperBound();
}
site = types.capture(site);
List<Type> args = rs.dummyArgs(tree.args.length());
Name name = TreeInfo.name(tree.meth);
@ -1374,7 +1357,9 @@ public class DeferredAttr extends JCTree.Visitor {
@Override
public Symbol process(MethodSymbol ms) {
ArgumentExpressionKind kind = ArgumentExpressionKind.methodKind(ms, types);
return kind != ArgumentExpressionKind.POLY ? ms.getReturnType().tsym : null;
if (kind == ArgumentExpressionKind.POLY || ms.getReturnType().hasTag(TYPEVAR))
return null;
return ms.getReturnType().tsym;
}
@Override
public Symbol reduce(Symbol s1, Symbol s2) {

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

@ -26,7 +26,6 @@
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;
@ -157,10 +156,4 @@ 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;
}
}

40
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Flow.java
View File

@ -208,7 +208,7 @@ public class Flow {
public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
new AliveAnalyzer().analyzeTree(env, make);
new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit).analyzeTree(env);
new AssignAnalyzer().analyzeTree(env);
new FlowAnalyzer().analyzeTree(env, make);
new CaptureAnalyzer().analyzeTree(env, make);
}
@ -241,13 +241,13 @@ public class Flow {
//related errors, which will allow for more errors to be detected
Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
try {
new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit) {
new AssignAnalyzer() {
@Override
protected boolean trackable(VarSymbol sym) {
return !env.info.scope.includes(sym) &&
sym.owner.kind == MTH;
}
}.analyzeTree(env);
}.analyzeTree(env, that);
LambdaFlowAnalyzer flowAnalyzer = new LambdaFlowAnalyzer();
flowAnalyzer.analyzeTree(env, that, make);
return flowAnalyzer.inferredThrownTypes;
@ -1369,12 +1369,12 @@ public class Flow {
* effectively-final local variables/parameters.
*/
public abstract static class AbstractAssignAnalyzer<P extends AbstractAssignAnalyzer.AbstractAssignPendingExit>
public abstract class AbstractAssignAnalyzer<P extends AbstractAssignAnalyzer<P>.AbstractAssignPendingExit>
extends BaseAnalyzer<P> {
/** The set of definitely assigned variables.
*/
protected final Bits inits;
protected Bits inits;
/** The set of definitely unassigned variables.
*/
@ -1428,13 +1428,7 @@ public class Flow {
/** The starting position of the analysed tree */
int startPos;
final Symtab syms;
protected Names names;
final boolean enforceThisDotInit;
public static class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
public class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
final Bits inits;
final Bits uninits;
@ -1456,17 +1450,14 @@ public class Flow {
}
}
public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names, boolean enforceThisDotInit) {
this.inits = inits;
public AbstractAssignAnalyzer() {
this.inits = new Bits();
uninits = new Bits();
uninitsTry = new Bits();
initsWhenTrue = new Bits(true);
initsWhenFalse = new Bits(true);
uninitsWhenTrue = new Bits(true);
uninitsWhenFalse = new Bits(true);
this.syms = syms;
this.names = names;
this.enforceThisDotInit = enforceThisDotInit;
}
private boolean isInitialConstructor = false;
@ -2431,26 +2422,15 @@ public class Flow {
}
}
public static class AssignAnalyzer
extends AbstractAssignAnalyzer<AssignAnalyzer.AssignPendingExit> {
public class AssignAnalyzer extends AbstractAssignAnalyzer<AssignAnalyzer.AssignPendingExit> {
Log log;
Lint lint;
public static class AssignPendingExit
extends AbstractAssignAnalyzer.AbstractAssignPendingExit {
public class AssignPendingExit extends AbstractAssignAnalyzer<AssignPendingExit>.AbstractAssignPendingExit {
public AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
super(tree, inits, uninits);
}
}
public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names, boolean enforceThisDotInit) {
super(new Bits(), syms, names, enforceThisDotInit);
this.log = log;
this.lint = lint;
}
@Override
protected AssignPendingExit createNewPendingExit(JCTree tree,
Bits inits, Bits uninits) {

238
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/MemberEnter.java
View File

@ -44,7 +44,6 @@ import com.sun.tools.javac.util.DefinedBy.Api;
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.*;
@ -85,6 +84,7 @@ 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;
@ -112,6 +112,7 @@ 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);
@ -143,13 +144,6 @@ 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 ----------------
*/
@ -278,7 +272,6 @@ 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,
@ -287,89 +280,33 @@ 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(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;
Type signature(MethodSymbol msym,
List<JCTypeParameter> typarams,
List<JCVariableDecl> params,
JCTree res,
JCVariableDecl recvparam,
List<JCExpression> thrown,
Env<AttrContext> env) {
// Enter and attribute type parameters.
List<Type> tvars = enter.classEnter(typarams, env);
attr.attribTypeVariables(typarams, env);
// 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.
// Enter and attribute value parameters.
ListBuffer<Type> argbuf = new ListBuffer<>();
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));
for (List<JCVariableDecl> l = params; l.nonEmpty(); l = l.tail) {
memberEnter(l.head, env);
argbuf.append(l.head.vartype.type);
}
// Attribute result type, if one is given.
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;
}
Type restype = res == null ? syms.voidType : attr.attribType(res, env);
// Attribute receiver type, if one is given.
Type recvtype;
if (recvparam!=null) {
// The type will get annotated by visitVarDef
memberEnter(recvparam, env, annotate.receiverCreator);
memberEnter(recvparam, env);
recvtype = recvparam.vartype.type;
} else {
recvtype = null;
@ -377,12 +314,8 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
// Attribute thrown exceptions.
ListBuffer<Type> thrownbuf = new ListBuffer<>();
i = 0;
for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail, i++) {
for (List<JCExpression> l = thrown; l.nonEmpty(); l = l.tail) {
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) {
@ -437,49 +370,33 @@ 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,
Annotate.PositionCreator creator) {
protected void memberEnter(JCTree tree, Env<AttrContext> env) {
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,
Annotate.PositionCreator creator) {
void memberEnter(List<? extends JCTree> trees, Env<AttrContext> env) {
for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
memberEnter(l.head, env, creator);
}
void memberEnter(List<? extends JCTree> trees,
Env<AttrContext> env) {
memberEnter(trees, env, annotate.noCreator);
memberEnter(l.head, env);
}
/** Enter members for a class.
*/
void finishClass(final JCClassDecl tree, final Env<AttrContext> env) {
void finishClass(JCClassDecl tree, 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, annotate.fieldCreator);
memberEnter(tree.defs, env);
}
/** Add the implicit members for an enum type
@ -554,7 +471,7 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
}
// process package annotations
annotate.annotateLater(tree.annotations, env, env.toplevel.packge);
annotate.annotateLater(tree.annotations, env, env.toplevel.packge, null);
}
// process the non-static imports and the static imports of types.
@ -602,13 +519,15 @@ 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.mods.annotations, tree.pos());
tree.thrown,
localEnv);
} finally {
deferredLintHandler.setPos(prevLintPos);
}
@ -635,9 +554,16 @@ 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, annotate.noCreator);
annotateDefaultValueLater(tree.defaultValue, localEnv, m);
} finally {
annotate.enterDone();
}
}
/** Create a fresh environment for method bodies.
@ -706,18 +632,10 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
chk.checkTransparentVar(tree.pos(), v, enclScope);
enclScope.enter(v);
}
if (TreeInfo.isReceiverParam(tree)) {
// 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);
}
annotate.annotateLater(tree.mods.annotations, localEnv, v, tree.pos());
annotate.annotateTypeLater(tree.vartype, localEnv, v, tree.pos());
v.pos = tree.pos;
} finally {
annotate.enterDone();
@ -889,8 +807,7 @@ 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 Annotate.PositionCreator creator) {
final MethodSymbol m) {
annotate.normal(new Annotate.Worker() {
@Override
public String toString() {
@ -979,38 +896,19 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
// create an environment for evaluating the base clauses
Env<AttrContext> baseEnv = baseEnv(tree, env);
// 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());
}
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();
// Determine supertype.
Type supertype;
if (tree.extending != null) {
dependencies.push(AttributionKind.EXTENDS, tree.extending);
try {
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);
}
} finally {
dependencies.pop();
}
@ -1029,7 +927,6 @@ 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) {
dependencies.push(AttributionKind.IMPLEMENTS, iface);
try {
@ -1042,19 +939,6 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
if (all_interfaces == null)
all_interfaces = new ListBuffer<Type>().appendList(interfaces);
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++));
}
} finally {
dependencies.pop();
@ -1083,28 +967,22 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
}
}
// class type parameters use baseEnv but everything uses env
// 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());
chk.checkNonCyclicDecl(tree);
// class type parameters use baseEnv but everything uses env
attr.attribTypeVariables(tree.typarams, baseEnv);
// Do this here, where we have the symbol.
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));
}
}
for (JCTypeParameter tp : tree.typarams)
annotate.annotateTypeLater(tp, baseEnv, sym, tree.pos());
// Add default constructor if needed.
if ((c.flags() & INTERFACE) == 0 &&
@ -1187,6 +1065,10 @@ public class MemberEnter extends JCTree.Visitor implements Completer {
Env<AttrContext> toFinish = halfcompleted.next();
topLevels.add(toFinish.toplevel);
finish(toFinish);
if (allowTypeAnnos) {
typeAnnotations.organizeTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
typeAnnotations.validateTypeAnnotationsSignatures(toFinish, (JCClassDecl)toFinish.tree);
}
}
} finally {
isFirst = true;

44
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
View File

@ -2992,7 +2992,7 @@ public class Resolve {
/**
* Should lookup stop at given phase with given result
*/
protected boolean shouldStop(Symbol sym, MethodResolutionPhase phase) {
final boolean shouldStop(Symbol sym, MethodResolutionPhase phase) {
return phase.ordinal() > maxPhase.ordinal() ||
sym.kind < ERRONEOUS || sym.kind == AMBIGUOUS;
}
@ -4174,15 +4174,39 @@ public class Resolve {
VARARITY(true, true) {
@Override
public Symbol mergeResults(Symbol bestSoFar, Symbol sym) {
switch (sym.kind) {
case WRONG_MTH:
return (bestSoFar.kind == WRONG_MTH || bestSoFar.kind == WRONG_MTHS) ?
bestSoFar :
sym;
case ABSENT_MTH:
return bestSoFar;
default:
return sym;
//Check invariants (see {@code LookupHelper.shouldStop})
Assert.check(bestSoFar.kind >= ERRONEOUS && bestSoFar.kind != AMBIGUOUS);
if (sym.kind < ERRONEOUS) {
//varargs resolution successful
return sym;
} else {
//pick best error
switch (bestSoFar.kind) {
case WRONG_MTH:
case WRONG_MTHS:
//Override previous errors if they were caused by argument mismatch.
//This generally means preferring current symbols - but we need to pay
//attention to the fact that the varargs lookup returns 'less' candidates
//than the previous rounds, and adjust that accordingly.
switch (sym.kind) {
case WRONG_MTH:
//if the previous round matched more than one method, return that
//result instead
return bestSoFar.kind == WRONG_MTHS ?
bestSoFar : sym;
case ABSENT_MTH:
//do not override erroneous symbol if the arity lookup did not
//match any method
return bestSoFar;
case WRONG_MTHS:
default:
//safe to override
return sym;
}
default:
//otherwise, return first error
return bestSoFar;
}
}
}
};

8
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/file/FSInfo.java
View File

@ -82,10 +82,10 @@ public class FSInfo {
for (StringTokenizer st = new StringTokenizer(path);
st.hasMoreTokens(); ) {
String elt = st.nextToken();
try {
File f = parent == null ? new File(elt): new File(file.toURI().resolve(elt));
list.add(f);
} catch (IllegalArgumentException ex) {}
File f = new File(elt);
if (!f.isAbsolute() && parent != null)
f = new File(parent,elt).getAbsoluteFile();
list.add(f);
}
return list;

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

@ -1588,6 +1588,8 @@ 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/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassWriter.java
View File

@ -740,13 +740,25 @@ public class ClassWriter extends ClassFile {
ListBuffer<Attribute.TypeCompound> invisibles = new ListBuffer<>();
for (Attribute.TypeCompound tc : typeAnnos) {
Assert.checkNonNull(tc.position);
if (tc.position.type.isLocal() != inCode) {
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);
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;
@ -927,6 +939,8 @@ 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);
}

80
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java
View File

@ -74,6 +74,7 @@ public class Gen extends JCTree.Visitor {
private Name accessDollar;
private final Types types;
private final Lower lower;
private final Flow flow;
/** Format of stackmap tables to be generated. */
private final Code.StackMapFormat stackMap;
@ -113,6 +114,7 @@ public class Gen extends JCTree.Visitor {
stringBufferAppend = new HashMap<>();
accessDollar = names.
fromString("access" + target.syntheticNameChar());
flow = Flow.instance(context);
lower = Lower.instance(context);
Options options = Options.instance(context);
@ -519,6 +521,7 @@ 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 {
@ -1818,7 +1821,10 @@ public class Gen extends JCTree.Visitor {
|| code.meth.getKind() == javax.lang.model.element.ElementKind.STATIC_INIT;
for (Attribute.TypeCompound ta : meth.getRawTypeAttributes()) {
if (ta.position != null && ta.position.matchesPos(treePos))
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
@ -1826,7 +1832,10 @@ public class Gen extends JCTree.Visitor {
return;
for (Attribute.TypeCompound ta : meth.owner.getRawTypeAttributes()) {
if (ta.position != null && ta.position.matchesPos(treePos))
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
@ -1836,7 +1845,10 @@ public class Gen extends JCTree.Visitor {
continue;
for (Attribute.TypeCompound ta : s.getRawTypeAttributes()) {
if (ta.position != null && ta.position.matchesPos(treePos))
if (ta.hasUnknownPosition())
ta.tryFixPosition();
if (ta.position.matchesPos(treePos))
ta.position.updatePosOffset(code.cp);
}
}
@ -2208,8 +2220,8 @@ public class Gen extends JCTree.Visitor {
}
public void visitTypeTest(JCInstanceOf tree) {
genExpr(tree.expr, tree.expr.type).load();
setTypeAnnotationPositions(tree.pos);
genExpr(tree.expr, tree.expr.type).load();
code.emitop2(instanceof_, makeRef(tree.pos(), tree.clazz.type));
result = items.makeStackItem(syms.booleanType);
}
@ -2373,9 +2385,7 @@ public class Gen extends JCTree.Visitor {
*/
if (varDebugInfo && (cdef.sym.flags() & SYNTHETIC) == 0) {
try {
LVTAssignAnalyzer lvtAssignAnalyzer = LVTAssignAnalyzer.make(
lvtRanges, syms, names);
lvtAssignAnalyzer.analyzeTree(localEnv);
new LVTAssignAnalyzer().analyzeTree(localEnv);
} catch (Throwable e) {
throw e;
}
@ -2466,11 +2476,10 @@ public class Gen extends JCTree.Visitor {
}
}
static class LVTAssignAnalyzer
class LVTAssignAnalyzer
extends Flow.AbstractAssignAnalyzer<LVTAssignAnalyzer.LVTAssignPendingExit> {
final LVTBits lvtInits;
final LVTRanges lvtRanges;
/* This class is anchored to a context dependent tree. The tree can
* vary inside the same instruction for example in the switch instruction
@ -2478,35 +2487,12 @@ public class Gen extends JCTree.Visitor {
* to a given case. The aim is to always anchor the bits to the tree
* capable of closing a DA range.
*/
static class LVTBits extends Bits {
enum BitsOpKind {
INIT,
CLEAR,
INCL_BIT,
EXCL_BIT,
ASSIGN,
AND_SET,
OR_SET,
DIFF_SET,
XOR_SET,
INCL_RANGE,
EXCL_RANGE,
}
class LVTBits extends Bits {
JCTree currentTree;
LVTAssignAnalyzer analyzer;
private int[] oldBits = null;
BitsState stateBeforeOp;
LVTBits() {
super(false);
}
LVTBits(int[] bits, BitsState initState) {
super(bits, initState);
}
@Override
public void clear() {
generalOp(null, -1, BitsOpKind.CLEAR);
@ -2614,12 +2600,11 @@ public class Gen extends JCTree.Visitor {
if (currentTree != null &&
stateBeforeOp != BitsState.UNKNOWN &&
trackTree(currentTree)) {
List<VarSymbol> locals =
analyzer.lvtRanges
.getVars(analyzer.currentMethod, currentTree);
List<VarSymbol> locals = lvtRanges
.getVars(currentMethod, currentTree);
locals = locals != null ?
locals : List.<VarSymbol>nil();
for (JCVariableDecl vardecl : analyzer.vardecls) {
for (JCVariableDecl vardecl : vardecls) {
//once the first is null, the rest will be so.
if (vardecl == null) {
break;
@ -2629,7 +2614,7 @@ public class Gen extends JCTree.Visitor {
}
}
if (!locals.isEmpty()) {
analyzer.lvtRanges.setEntry(analyzer.currentMethod,
lvtRanges.setEntry(currentMethod,
currentTree, locals);
}
}
@ -2647,7 +2632,7 @@ public class Gen extends JCTree.Visitor {
boolean trackVar(VarSymbol var) {
return (var.owner.kind == MTH &&
(var.flags() & PARAMETER) == 0 &&
analyzer.trackable(var));
trackable(var));
}
boolean trackTree(JCTree tree) {
@ -2663,7 +2648,8 @@ public class Gen extends JCTree.Visitor {
}
public class LVTAssignPendingExit extends Flow.AssignAnalyzer.AssignPendingExit {
public class LVTAssignPendingExit extends
Flow.AbstractAssignAnalyzer<LVTAssignPendingExit>.AbstractAssignPendingExit {
LVTAssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
super(tree, inits, uninits);
@ -2676,16 +2662,10 @@ public class Gen extends JCTree.Visitor {
}
}
private LVTAssignAnalyzer(LVTRanges lvtRanges, Symtab syms, Names names) {
super(new LVTBits(), syms, names, false);
lvtInits = (LVTBits)inits;
this.lvtRanges = lvtRanges;
}
public static LVTAssignAnalyzer make(LVTRanges lvtRanges, Symtab syms, Names names) {
LVTAssignAnalyzer result = new LVTAssignAnalyzer(lvtRanges, syms, names);
result.lvtInits.analyzer = result;
return result;
private LVTAssignAnalyzer() {
flow.super();
lvtInits = new LVTBits();
inits = lvtInits;
}
@Override

14
langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/util/Bits.java
View File

@ -84,6 +84,20 @@ public class Bits {
}
public enum BitsOpKind {
INIT,
CLEAR,
INCL_BIT,
EXCL_BIT,
ASSIGN,
AND_SET,
OR_SET,
DIFF_SET,
XOR_SET,
INCL_RANGE,
EXCL_RANGE,
}
private final static int wordlen = 32;
private final static int wordshift = 5;
private final static int wordmask = wordlen - 1;

2
langtools/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java
View File

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

27
langtools/test/tools/javac/ConditionalWithVoid.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2004, 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
* @test /nodynamiccopyright/
* @bug 4974927
* @summary The compiler was allowing void types in its parsing of conditional expressions.
* @author tball
*
* @compile/fail ConditionalWithVoid.java
* @compile/fail/ref=ConditionalWithVoid.out -XDrawDiagnostics ConditionalWithVoid.java
*/
public class ConditionalWithVoid {
public int test(Object o) {

2
langtools/test/tools/javac/ConditionalWithVoid.out Normal file
View File

@ -0,0 +1,2 @@
ConditionalWithVoid.java:12:48: compiler.err.neither.conditional.subtype: java.lang.Integer, void
1 error

29
langtools/test/tools/javac/DuplicateClass.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2001, 2002, 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
* @test /nodynamiccopyright/
* @bug 4531500
* @summary Cascade of problems from duplicate class can cause compiler crash.
* @author gafter
*
* @compile/fail DuplicateClass.java
* @compile/fail/ref=DuplicateClass.out -XDrawDiagnostics DuplicateClass.java
*/
/**
@ -36,7 +13,7 @@
* processing it.
*/
public class DuplicateClass {
protected void clone() {
protected Object clone() {
super.clone();
}
}

2
langtools/test/tools/javac/DuplicateClass.out Normal file
View File

@ -0,0 +1,2 @@
DuplicateClass.java:21:8: compiler.err.duplicate.class: DuplicateClass
1 error

27
langtools/test/tools/javac/EOI.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2004, 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
* @test /nodynamiccopyright/
* @bug 5016879
* @summary REGRESSION: translation unit ending in identifier crashes javac
* @author gafter
*
* @compile/fail EOI.java
* @compile/fail/ref=EOI.out -XDrawDiagnostics EOI.java
*/
class foobar {}

2
langtools/test/tools/javac/EOI.out Normal file
View File

@ -0,0 +1,2 @@
EOI.java:11:1: compiler.err.premature.eof
1 error

27
langtools/test/tools/javac/ExceptionalFinally2.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2002, 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
* @test /nodynamiccopyright/
* @bug 4630634
* @summary missing warn about exception not thrown in try block if finally can't complete
* @author gafter
*
* @compile/fail ExceptionalFinally2.java
* @compile/fail/ref=ExceptionalFinally2.out -XDrawDiagnostics ExceptionalFinally2.java
*/
class ExceptionalFinally2 {

2
langtools/test/tools/javac/ExceptionalFinally2.out Normal file
View File

@ -0,0 +1,2 @@
ExceptionalFinally2.java:22:11: compiler.err.except.never.thrown.in.try: ExceptionalFinally2.E
1 error

27
langtools/test/tools/javac/ExprQualifiedType.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2000, 2001, 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
* @test /nodynamiccopyright/
* @bug 4347611 4440249 4508227
* @summary Check that qualified reference to type via an expression does not crash compiler.
* @author maddox
*
* @compile/fail ExprQualifiedType.java
* @compile/fail/ref=ExprQualifiedType.out -XDrawDiagnostics ExprQualifiedType.java
*/
public class ExprQualifiedType {

3
langtools/test/tools/javac/ExprQualifiedType.out Normal file
View File

@ -0,0 +1,3 @@
ExprQualifiedType.java:18:9: compiler.err.unexpected.type: kindname.class,kindname.package, kindname.value
ExprQualifiedType.java:19:9: compiler.err.unexpected.type: kindname.class,kindname.package, kindname.value
2 errors

27
langtools/test/tools/javac/ExtendsScope.java
View File

@ -1,34 +1,11 @@
/*
* Copyright (c) 2002, 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
* @test /nodynamiccopyright/
* @bug 4402884
* @summary javac improperly extends superclass's scope to implements clause
* @author gafter
*
* @clean I
* @compile/fail ExtendsScope.java
* @compile/fail/ref=ExtendsScope.out -XDrawDiagnostics ExtendsScope.java
*/
class P {

2
langtools/test/tools/javac/ExtendsScope.out Normal file
View File

@ -0,0 +1,2 @@
ExtendsScope.java:15:30: compiler.err.cant.resolve: kindname.class, I, ,
1 error

27
langtools/test/tools/javac/ExtraneousEquals.java
View File

@ -1,32 +1,9 @@
/*
* Copyright (c) 2004, 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
* @test /nodynamiccopyright/
* @bug 5019614
* @summary variance prototype syntax leftover
*
* @compile/fail ExtraneousEquals.java
* @compile/fail/ref=ExtraneousEquals.out -XDrawDiagnostics ExtraneousEquals.java
*/
public class ExtraneousEquals {

6
langtools/test/tools/javac/ExtraneousEquals.out Normal file
View File

@ -0,0 +1,6 @@
ExtraneousEquals.java:10:23: compiler.err.illegal.start.of.expr
ExtraneousEquals.java:10:24: compiler.err.illegal.start.of.expr
ExtraneousEquals.java:10:25: compiler.err.expected: ';'
ExtraneousEquals.java:10:28: compiler.err.not.stmt
ExtraneousEquals.java:10:29: compiler.err.expected: ';'
5 errors

27
langtools/test/tools/javac/FlatnameClash2.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2002, 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
* @test /nodynamiccopyright/
* @bug 4629327
* @summary Compiler crash on explicit use of synthetic name for inner class.
* @author Neal Gafter
*
* @compile/fail FlatnameClash2.java
* @compile/fail/ref=FlatnameClash2.out -XDrawDiagnostics FlatnameClash2.java
*/
package tests;

3
langtools/test/tools/javac/FlatnameClash2.out Normal file
View File

@ -0,0 +1,3 @@
FlatnameClash2.java:32:22: compiler.err.cant.resolve.location: kindname.class, T1$Inner1, , , (compiler.misc.location: kindname.package, tests, null)
FlatnameClash2.java:28:14: compiler.err.cant.apply.symbol: kindname.method, print, tests.T1.Inner1, tests.T2.Inner2, kindname.class, tests.T1, (compiler.misc.no.conforming.assignment.exists: (compiler.misc.inconvertible.types: tests.T2.Inner2, tests.T1.Inner1))
2 errors

27
langtools/test/tools/javac/InconsistentInheritedSignature.java
View File

@ -1,34 +1,11 @@
/*
* Copyright (c) 1997, 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
* @test /nodynamiccopyright/
* @bug 4041948
* @summary javac previously allowed interfaces to inherit methods with
* inconsistent signatures.
* @author turnidge
*
* @compile/fail InconsistentInheritedSignature.java
* @compile/fail/ref=InconsistentInheritedSignature.out -XDrawDiagnostics InconsistentInheritedSignature.java
*/
interface I1{
int f();

2
langtools/test/tools/javac/InconsistentInheritedSignature.out Normal file
View File

@ -0,0 +1,2 @@
InconsistentInheritedSignature.java:17:1: compiler.err.types.incompatible.diff.ret: I2, I1, f()
1 error

27
langtools/test/tools/javac/InterfaceObjectIncompatibility.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2002, 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
* @test /nodynamiccopyright/
* @bug 4479164
* @summary Throws clauses incompatible with Object methods allowed in interfaces
* @author gafter
*
* @compile/fail InterfaceObjectIncompatibility.java
* @compile/fail/ref=InterfaceObjectIncompatibility.out -XDrawDiagnostics InterfaceObjectIncompatibility.java
*/
interface InterfaceObjectIncompatibility {

3
langtools/test/tools/javac/InterfaceObjectIncompatibility.out Normal file
View File

@ -0,0 +1,3 @@
InterfaceObjectIncompatibility.java:12:12: compiler.err.override.meth.doesnt.throw: (compiler.misc.cant.override: toString(), InterfaceObjectIncompatibility, toString(), java.lang.Object), java.io.IOException
InterfaceObjectIncompatibility.java:13:9: compiler.err.override.meth.doesnt.throw: (compiler.misc.cant.override: hashCode(), InterfaceObjectIncompatibility, hashCode(), java.lang.Object), java.lang.Exception
2 errors

27
langtools/test/tools/javac/InterfaceObjectInheritance.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2002, 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
* @test /nodynamiccopyright/
* @bug 4526026
* @summary javac allows access to interface members inherited protected from Object
* @author gafter
*
* @compile/fail InterfaceObjectInheritance.java
* @compile/fail/ref=InterfaceObjectInheritance.out -XDrawDiagnostics InterfaceObjectInheritance.java
*/
interface InterfaceObjectInheritance {

2
langtools/test/tools/javac/InterfaceObjectInheritance.out Normal file
View File

@ -0,0 +1,2 @@
InterfaceObjectInheritance.java:17:18: compiler.err.cant.resolve.location.args: kindname.method, finalize, , , (compiler.misc.location.1: kindname.variable, i, InterfaceObjectInheritance)
1 error

30
langtools/test/tools/javac/InterfaceOverrideFinal.java
View File

@ -1,31 +1,9 @@
/*
* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
* @test /nodynamiccopyright/
* @bug 4668238 4721069
* @summary compiler must reject interface "overriding" final Object meth.
* @compile/fail/ref=InterfaceOverrideFinal.out -XDrawDiagnostics InterfaceOverrideFinal.java
*/
/* @test
@bug 4668238 4721069
@summary compiler must reject interface "overriding" final Object meth.
@compile/fail InterfaceOverrideFinal.java
*/
public interface InterfaceOverrideFinal {
void notify();
}

2
langtools/test/tools/javac/InterfaceOverrideFinal.out Normal file
View File

@ -0,0 +1,2 @@
InterfaceOverrideFinal.java:8:10: compiler.err.override.meth: (compiler.misc.cant.override: notify(), InterfaceOverrideFinal, notify(), java.lang.Object), final
1 error

27
langtools/test/tools/javac/LabeledDeclaration.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 1998, 2001, 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
* @test /nodynamiccopyright/
* @bug 4039843
* @summary The compiler should not allow labeled declarations.
* @author turnidge
*
* @compile/fail LabeledDeclaration.java
* @compile/fail/ref=LabeledDeclaration.out -XDrawDiagnostics LabeledDeclaration.java
*/
class LabeledDeclaration {

3
langtools/test/tools/javac/LabeledDeclaration.out Normal file
View File

@ -0,0 +1,3 @@
LabeledDeclaration.java:12:14: compiler.err.dot.class.expected
LabeledDeclaration.java:12:10: compiler.err.not.stmt
2 errors

27
langtools/test/tools/javac/NestedDuplicateLabels.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 1998, 2001, 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
* @test /nodynamiccopyright/
* @bug 1241001
* @summary The compiler failed to detect duplicate, nested labels.
* @author turnidge
*
* @compile/fail NestedDuplicateLabels.java
* @compile/fail/ref=NestedDuplicateLabels.out -XDrawDiagnostics NestedDuplicateLabels.java
*/
class NestedDuplicateLabels {

2
langtools/test/tools/javac/NestedDuplicateLabels.out Normal file
View File

@ -0,0 +1,2 @@
NestedDuplicateLabels.java:12:14: compiler.err.label.already.in.use: foo
1 error

27
langtools/test/tools/javac/NewGeneric.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2004, 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
* @test /nodynamiccopyright/
* @bug 4959929
* @summary unclear diagnostic for "new T()"
* @author never
*
* @compile/fail NewGeneric.java
* @compile/fail/ref=NewGeneric.out -XDrawDiagnostics NewGeneric.java
*/

2
langtools/test/tools/javac/NewGeneric.out Normal file
View File

@ -0,0 +1,2 @@
NewGeneric.java:13:28: compiler.err.type.found.req: (compiler.misc.type.parameter: T), (compiler.misc.type.req.class)
1 error

27
langtools/test/tools/javac/Object1.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2001, 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
* @test /nodynamiccopyright/
* @bug 4091755
* @summary java.lang.Object can't be redefined without crashing javac
* @author gafter
*
* @compile/fail Object1.java
* @compile/fail/ref=Object1.out -XDrawDiagnostics Object1.java
*/
package java.lang;

2
langtools/test/tools/javac/Object1.out Normal file
View File

@ -0,0 +1,2 @@
Object1.java:11:22: compiler.err.cyclic.inheritance: java.lang.Throwable
1 error

27
langtools/test/tools/javac/Object2.java
View File

@ -1,33 +1,10 @@
/*
* Copyright (c) 2001, 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
* @test /nodynamiccopyright/
* @bug 4091755
* @summary java.lang.Object can't be redefined without crashing javac
* @author gafter
*
* @compile/fail Object2.java
* @compile/fail/ref=Object2.out -XDrawDiagnostics Object2.java
*/
package java.lang;

2
langtools/test/tools/javac/Object2.out Normal file
View File

@ -0,0 +1,2 @@
Object2.java:11:25: compiler.err.cyclic.inheritance: java.lang.Cloneable
1 error

4
langtools/test/tools/javac/Paths/AbsolutePathTest.java
View File

@ -23,11 +23,11 @@
/*
* @test
* @ignore 8055500 [javac] fix for 8030046 is incorrect
* @bug 8030046
* @bug 8030046 8055500
* @summary javac incorrectly handles absolute paths in manifest classpath
* @author govereau
* @library /tools/lib
* @ignore 8055768 ToolBox does not close opened files
* @build ToolBox
* @run main AbsolutePathTest
*/

3
langtools/test/tools/javac/T6725036.java
View File

@ -23,8 +23,7 @@
/*
* @test
* @bug 6725036
* @ignore 8016760: failure of regression test langtools/tools/javac/T6725036.java
* @bug 6725036 8016760
* @summary javac returns incorrect value for lastModifiedTime() when
* source is a zip file archive
*/

1
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotatePackages.java
View File

@ -3,6 +3,7 @@
* @bug 8026564
* @summary The parts of a fully-qualified type can't be annotated.
* @author Werner Dietl
* @ignore 8057679 clarify error messages trying to annotate scoping
* @compile/fail/ref=CantAnnotatePackages.out -XDrawDiagnostics CantAnnotatePackages.java
*/

1
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.java
View File

@ -3,6 +3,7 @@
* @bug 8006733 8006775
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore 8057679 clarify error messages trying to annotate scoping
* @compile/fail/ref=CantAnnotateScoping.out -XDrawDiagnostics CantAnnotateScoping.java
*/

2
langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateStaticClass2.java
View File

@ -3,6 +3,8 @@
* @bug 8006733 8006775
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore 8057679 clarify error messages trying to annotate scoping
* @ignore 8057683 improve ordering of errors with type annotations
* @compile/fail/ref=CantAnnotateStaticClass2.out -XDrawDiagnostics CantAnnotateStaticClass2.java
*/

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

@ -3,6 +3,8 @@
* @bug 8006733 8006775 8027262
* @summary Ensure behavior for nested types is correct.
* @author Werner Dietl
* @ignore 8057679 clarify error messages trying to annotate scoping
* @ignore 8057683 improve order of errors with type annotations
* @compile/fail/ref=CantAnnotateStaticClass3.out -XDrawDiagnostics CantAnnotateStaticClass3.java
*/

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

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

@ -25,6 +25,7 @@
* @test
* @bug 8027262
* @summary Stress test for type annotatons
* @ignore 8057685 javac should not crash compiling type annotations
* @compile AllLocations.java
*/

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

@ -28,6 +28,7 @@ import java.lang.annotation.*;
* @bug 8006775
* @summary repeating type annotations are possible
* @author Werner Dietl
* @ignore 8057683 improve ordering of errors with type annotations
* @compile/fail/ref=RepeatingTypeAnnotations.out -XDrawDiagnostics RepeatingTypeAnnotations.java
*/

3
langtools/test/tools/javac/annotations/typeAnnotations/referenceinfos/Lambda.java
View File

@ -25,7 +25,8 @@
* @test
* @bug 8008077 8029721 8042451 8043974
* @summary Test population of reference info for lambda expressions
* javac crash for annotated parameter type of lambda in a field
* javac crash for annotated parameter type of lambda in a field
* @ignore 8057687 emit correct byte code an attributes for type annotations
* @compile -g Driver.java ReferenceInfoUtil.java Lambda.java
* @run main Driver Lambda
* @author Werner Dietl

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

@ -27,6 +27,7 @@ import static com.sun.tools.classfile.TypeAnnotation.TargetType.*;
* @test
* @bug 8042451 8044009 8044010
* @summary Test population of reference info for nested types
* @ignore 8057687 emit correct byte code an attributes for type annotations
* @compile -g Driver.java ReferenceInfoUtil.java NestedTypes.java
* @run main Driver NestedTypes
*/

44
langtools/test/tools/javac/flow/T8042741/LambdaArgumentsTest.java Normal file
View File

@ -0,0 +1,44 @@
/*
* 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 8054210
* @summary NullPointerException when compiling specific code
* @compile LambdaArgumentsTest.java
*/
public class LambdaArgumentsTest {
interface Thrower<E extends Exception> { void apply() throws E; }
interface Consumer<E> { void take(E arg); }
<E extends Exception>
void m1(Thrower<E> a1, Consumer<E> a2) {}
<E extends Exception>
void m2(Thrower<E> a1, Consumer<RuntimeException> a2) {}
void test() {
m1(() -> {}, e -> {});
m2(() -> {}, (RuntimeException e) -> {});
}
}

2
langtools/test/tools/javac/importChecks/InvalidImportsNoClasses.java
View File

@ -1,6 +1,6 @@
/*
* @test /nodynamiccopyright/
* @bug 4312063
* @bug 4041851 4312063
* @summary Verify that nonexistent imports detected when no classes declared in compilation unit.
* @author maddox
*

70
langtools/test/tools/javac/lambda/T8056014.java Normal file
View File

@ -0,0 +1,70 @@
/*
* 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 8056014
* @summary Verify that full type inference is used when calling a method on a type variable.
* @compile T8056014.java
* @run main T8056014
*/
import java.util.*;
public class T8056014 {
public static void main(String[] args) {
new T8056014().run();
}
void run() {
List<S> l = Arrays.asList(new S());
C<S> c = new C<>(new S());
foo(l.get(0).copy(1));
foo(c.get(0).copy(1));
}
void foo(S d) {
}
}
class B {
public B copy(long j) {
throw new AssertionError("Should not get here.");
}
}
class S extends B {
public <T> T copy(int i) {
return null;
}
}
class C<T extends B> {
final T t;
public C(T t) {
this.t = t;
}
public T get(int i) {
return t;
}
}

26
langtools/test/tools/javac/NoClass.java → langtools/test/tools/javac/lambda/T8056984.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2001, Oracle and/or its affiliates. All rights reserved.
* 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
@ -23,13 +23,19 @@
/*
* @test
* @bug 4041851
* @summary The gramamr allows java files without class or interface
* declarations; when the compiler encountered this, it failed
* to check the validity of import declarations.
* @author turnidge
*
* @compile/fail NoClass.java
* @bug 8056984
* @summary Ensure that method resolution runs over a captured type variables when checking if
* deferred attribution is needed
* @compile T8056984.java
*/
import nonexistent.pack.cls;
class T8056984<T1 extends B&C, T2 extends T1> {
public T8056984(T1 t1, T2 t2) {
System.err.println(t1.hashCode());
System.err.println(t2.hashCode());
}
}
class B {
}
interface C {
public int hashCode();
}

3
langtools/test/tools/javac/processing/model/type/BasicAnnoTests.java
View File

@ -26,7 +26,8 @@
* @bug 8013852
* @summary Annotations on types
* @library /tools/javac/lib
* @ignore
* @ignore 8057688 type annotations in type argument position are lost
* @ignore 8031744 Annotations on many Language Model elements are not returned
* @build JavacTestingAbstractProcessor DPrinter BasicAnnoTests
* @compile/process -processor BasicAnnoTests -proc:only BasicAnnoTests.java
*/

26
langtools/test/tools/javac/varargs/8055514/T8055514.java Normal file
View File

@ -0,0 +1,26 @@
/*
* @test /nodynamiccopyright/
* @bug 8055514
* @summary Wrong, confusing error when non-static varargs referenced in static context
* @compile/fail/ref=T8055514.out -Xlint:varargs -Werror -XDrawDiagnostics T8055514.java
*/
class T8055514 {
void m(int... args) { }
void m2(int... args) { }
static void m2(String s) { }
void m3(int... args) { }
static void m3(String s) { }
static void m3(Runnable r) { }
void m4(int... args) { }
void m4(int i1, int i2, int i3) { }
static void test() {
m(1,2,3); //only one candidate (varargs) - varargs error wins
m2(1,2,3); //two candidates - only one applicable (varargs) - varargs error wins
m3(1,2,3); //three candidates - only one applicable (varargs) - varargs error wins
m4(1,2,3); //two candidates - both applicable - basic error wins
}
}

5
langtools/test/tools/javac/varargs/8055514/T8055514.out Normal file
View File

@ -0,0 +1,5 @@
T8055514.java:21:9: compiler.err.non-static.cant.be.ref: kindname.method, m(int...)
T8055514.java:22:9: compiler.err.non-static.cant.be.ref: kindname.method, m2(int...)
T8055514.java:23:9: compiler.err.non-static.cant.be.ref: kindname.method, m3(int...)
T8055514.java:24:9: compiler.err.non-static.cant.be.ref: kindname.method, m4(int,int,int)
4 errors

1
langtools/test/tools/javac/warnings/6747671/T6747671.java
View File

@ -34,6 +34,7 @@ class T6747671<E> {
}
@TA B @TA[] arr = new @TA B @TA [0];//JDK-8022567: raw warning (2)
//todo: 8057688 type annotations in type argument position are lost
Class<B[]> classes1;//no warning
Class<B>[] classes2;//no warning

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.TA T6747671.B, T6747671.B<X>
T6747671.java:36:27: compiler.warn.raw.class.use: T6747671.B, T6747671.B<X>
11 warnings

2
langtools/test/tools/javac/warnings/suppress/T6480588.java
View File

@ -7,7 +7,7 @@
* @compile/ref=T6480588.out -XDrawDiagnostics -Xlint:unchecked,deprecation,cast T6480588.java
* @run main VerifySuppressWarnings T6480588.java
*/
// TODO: 8057683 improve ordering of errors with type annotations
@DeprecatedAnnotation
class T6480588 extends DeprecatedClass implements DeprecatedInterface {
@DeprecatedAnnotation

4
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

1
langtools/test/tools/javac/warnings/suppress/TypeAnnotations.java
View File

@ -2,6 +2,7 @@
* @test /nodynamiccopyright/
* @bug 8021112
* @summary Verify that \\@SuppressWarnings("unchecked") works for type annotations
* @ignore 8057683 improve ordering of errors with type annotations
* @build VerifySuppressWarnings
* @compile/ref=TypeAnnotations.out -XDrawDiagnostics -Xlint:unchecked,deprecation,cast TypeAnnotations.java
* @run main VerifySuppressWarnings TypeAnnotations.java

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

@ -25,6 +25,7 @@
* @test
* @bug 8005220
* @summary javap must display repeating annotations
* @ignore 8057687 emit correct byte code an attributes for type annotations
*/
import java.io.*;
import java.util.*;