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

6939620: Switch to 'complex' diamond inference scheme

Browse source 
Implement new inference scheme for diamond operator that takes into account type of actual arguments supplied to constructor

Reviewed-by: jjg, darcy
This commit is contained in:
Maurizio Cimadamore 2010-04-14 12:31:55 +01:00
parent 965595d38b
commit d3fa7f79ad
36 changed files with 1368 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -122,6 +122,9 @@ public enum Source {
public boolean allowGenerics() { public boolean allowGenerics() {
return compareTo(JDK1_5) >= 0; return compareTo(JDK1_5) >= 0;
} }
public boolean allowDiamond() {
return compareTo(JDK1_7) >= 0;
}
public boolean allowEnums() { public boolean allowEnums() {
return compareTo(JDK1_5) >= 0; return compareTo(JDK1_5) >= 0;
} }

7
langtools/src/share/classes/com/sun/tools/javac/code/Symbol.java
View file

@ -225,6 +225,13 @@ public abstract class Symbol implements Element {
(owner.kind == TYP && owner.isLocal()); (owner.kind == TYP && owner.isLocal());
} }
/** Has this symbol an empty name? This includes anonymous
* inner classses.
*/
public boolean isAnonymous() {
return name.isEmpty();
}
/** Is this symbol a constructor? /** Is this symbol a constructor?
*/ */
public boolean isConstructor() { public boolean isConstructor() {

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

@ -72,6 +72,7 @@ public class Attr extends JCTree.Visitor {
final Log log; final Log log;
final Symtab syms; final Symtab syms;
final Resolve rs; final Resolve rs;
final Infer infer;
final Check chk; final Check chk;
final MemberEnter memberEnter; final MemberEnter memberEnter;
final TreeMaker make; final TreeMaker make;
@ -100,6 +101,7 @@ public class Attr extends JCTree.Visitor {
memberEnter = MemberEnter.instance(context); memberEnter = MemberEnter.instance(context);
make = TreeMaker.instance(context); make = TreeMaker.instance(context);
enter = Enter.instance(context); enter = Enter.instance(context);
infer = Infer.instance(context);
cfolder = ConstFold.instance(context); cfolder = ConstFold.instance(context);
target = Target.instance(context); target = Target.instance(context);
types = Types.instance(context); types = Types.instance(context);
@ -425,7 +427,14 @@ public class Attr extends JCTree.Visitor {
/** Derived visitor method: attribute a type tree. /** Derived visitor method: attribute a type tree.
*/ */
Type attribType(JCTree tree, Env<AttrContext> env) { Type attribType(JCTree tree, Env<AttrContext> env) {
Type result = attribTree(tree, env, TYP, Type.noType); Type result = attribType(tree, env, Type.noType);
return result;
}
/** Derived visitor method: attribute a type tree.
*/
Type attribType(JCTree tree, Env<AttrContext> env, Type pt) {
Type result = attribTree(tree, env, TYP, pt);
return result; return result;
} }
@ -532,6 +541,7 @@ public class Attr extends JCTree.Visitor {
} }
/** Attribute type reference in an `extends' or `implements' clause. /** Attribute type reference in an `extends' or `implements' clause.
* Supertypes of anonymous inner classes are usually already attributed.
* *
* @param tree The tree making up the type reference. * @param tree The tree making up the type reference.
* @param env The environment current at the reference. * @param env The environment current at the reference.
@ -543,7 +553,9 @@ public class Attr extends JCTree.Visitor {
boolean classExpected, boolean classExpected,
boolean interfaceExpected, boolean interfaceExpected,
boolean checkExtensible) { boolean checkExtensible) {
Type t = attribType(tree, env); Type t = tree.type != null ?
tree.type :
attribType(tree, env);
return checkBase(t, tree, env, classExpected, interfaceExpected, checkExtensible); return checkBase(t, tree, env, classExpected, interfaceExpected, checkExtensible);
} }
Type checkBase(Type t, Type checkBase(Type t,
@ -1448,13 +1460,16 @@ public class Attr extends JCTree.Visitor {
((JCTypeApply) clazz).arguments); ((JCTypeApply) clazz).arguments);
else else
clazz = clazzid1; clazz = clazzid1;
// System.out.println(clazz + " generated.");//DEBUG
} }
// Attribute clazz expression and store // Attribute clazz expression and store
// symbol + type back into the attributed tree. // symbol + type back into the attributed tree.
Type clazztype = chk.checkClassType( Type clazztype = attribType(clazz, env);
tree.clazz.pos(), attribType(clazz, env), true); Pair<Scope,Scope> mapping = getSyntheticScopeMapping((ClassType)clazztype);
if (!TreeInfo.isDiamond(tree)) {
clazztype = chk.checkClassType(
tree.clazz.pos(), clazztype, true);
}
chk.validate(clazz, localEnv); chk.validate(clazz, localEnv);
if (tree.encl != null) { if (tree.encl != null) {
// We have to work in this case to store // We have to work in this case to store
@ -1479,6 +1494,11 @@ public class Attr extends JCTree.Visitor {
List<Type> argtypes = attribArgs(tree.args, localEnv); List<Type> argtypes = attribArgs(tree.args, localEnv);
List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv); List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);
if (TreeInfo.isDiamond(tree)) {
clazztype = attribDiamond(localEnv, tree, clazztype, mapping, argtypes, typeargtypes, true);
clazz.type = clazztype;
}
// If we have made no mistakes in the class type... // If we have made no mistakes in the class type...
if (clazztype.tag == CLASS) { if (clazztype.tag == CLASS) {
// Enums may not be instantiated except implicitly // Enums may not be instantiated except implicitly
@ -1606,6 +1626,136 @@ public class Attr extends JCTree.Visitor {
chk.validate(tree.typeargs, localEnv); chk.validate(tree.typeargs, localEnv);
} }
Type attribDiamond(Env<AttrContext> env,
JCNewClass tree,
Type clazztype,
Pair<Scope, Scope> mapping,
List<Type> argtypes,
List<Type> typeargtypes,
boolean reportErrors) {
if (clazztype.isErroneous()) {
//if the type of the instance creation expression is erroneous
//return the erroneous type itself
return clazztype;
}
else if (clazztype.isInterface()) {
//if the type of the instance creation expression is an interface
//skip the method resolution step (JLS 15.12.2.7). The type to be
//inferred is of the kind <X1,X2, ... Xn>C<X1,X2, ... Xn>
clazztype = new ForAll(clazztype.tsym.type.allparams(),
clazztype.tsym.type);
} else {
//if the type of the instance creation expression is a class type
//apply method resolution inference (JLS 15.12.2.7). The return type
//of the resolved constructor will be a partially instantiated type
((ClassSymbol) clazztype.tsym).members_field = mapping.snd;
Symbol constructor;
try {
constructor = rs.resolveDiamond(tree.pos(),
env,
clazztype.tsym.type,
argtypes,
typeargtypes, reportErrors);
} finally {
((ClassSymbol) clazztype.tsym).members_field = mapping.fst;
}
if (constructor.kind == MTH) {
ClassType ct = new ClassType(clazztype.getEnclosingType(),
clazztype.tsym.type.getTypeArguments(),
clazztype.tsym);
clazztype = checkMethod(ct,
constructor,
env,
tree.args,
argtypes,
typeargtypes,
env.info.varArgs).getReturnType();
} else {
clazztype = syms.errType;
}
}
if (clazztype.tag == FORALL && !pt.isErroneous()) {
//if the resolved constructor's return type has some uninferred
//type-variables, infer them using the expected type and declared
//bounds (JLS 15.12.2.8).
try {
clazztype = infer.instantiateExpr((ForAll) clazztype,
pt.tag == NONE ? syms.objectType : pt,
Warner.noWarnings);
} catch (Infer.InferenceException ex) {
//an error occurred while inferring uninstantiated type-variables
//we need to optionally report an error
if (reportErrors) {
log.error(tree.clazz.pos(),
"cant.apply.diamond.1",
diags.fragment("diamond", clazztype.tsym),
ex.diagnostic);
}
}
}
if (reportErrors) {
clazztype = chk.checkClassType(tree.clazz.pos(),
clazztype,
true);
if (clazztype.tag == CLASS) {
List<Type> invalidDiamondArgs = chk.checkDiamond((ClassType)clazztype);
if (!clazztype.isErroneous() && invalidDiamondArgs.nonEmpty()) {
//one or more types inferred in the previous steps is either a
//captured type or an intersection type --- we need to report an error.
String subkey = invalidDiamondArgs.size() > 1 ?
"diamond.invalid.args" :
"diamond.invalid.arg";
//The error message is of the kind:
//
//cannot infer type arguments for {clazztype}<>;
//reason: {subkey}
//
//where subkey is a fragment of the kind:
//
//type argument(s) {invalidDiamondArgs} inferred for {clazztype}<> is not allowed in this context
log.error(tree.clazz.pos(),
"cant.apply.diamond.1",
diags.fragment("diamond", clazztype.tsym),
diags.fragment(subkey,
invalidDiamondArgs,
diags.fragment("diamond", clazztype.tsym)));
}
}
}
return clazztype;
}
/** Creates a synthetic scope containing fake generic constructors.
* Assuming that the original scope contains a constructor of the kind:
* Foo(X x, Y y), where X,Y are class type-variables declared in Foo,
* the synthetic scope is added a generic constructor of the kind:
* <X,Y>Foo<X,Y>(X x, Y y). This is crucial in order to enable diamond
* inference. The inferred return type of the synthetic constructor IS
* the inferred type for the diamond operator.
*/
private Pair<Scope, Scope> getSyntheticScopeMapping(ClassType ctype) {
Pair<Scope, Scope> mapping =
new Pair<Scope, Scope>(ctype.tsym.members(), new Scope(ctype.tsym));
List<Type> typevars = ctype.tsym.type.getTypeArguments();
for (Scope.Entry e = mapping.fst.lookup(names.init);
e.scope != null;
e = e.next()) {
MethodSymbol newConstr = (MethodSymbol) e.sym.clone(ctype.tsym);
newConstr.name = names.init;
List<Type> oldTypeargs = List.nil();
if (newConstr.type.tag == FORALL) {
oldTypeargs = ((ForAll) newConstr.type).tvars;
}
newConstr.type = new MethodType(newConstr.type.getParameterTypes(),
new ClassType(ctype.getEnclosingType(), ctype.tsym.type.getTypeArguments(), ctype.tsym),
newConstr.type.getThrownTypes(),
syms.methodClass);
newConstr.type = new ForAll(typevars.prependList(oldTypeargs), newConstr.type);
mapping.snd.enter(newConstr);
}
return mapping;
}
/** Make an attributed null check tree. /** Make an attributed null check tree.
*/ */
public JCExpression makeNullCheck(JCExpression arg) { public JCExpression makeNullCheck(JCExpression arg) {
@ -2547,7 +2697,7 @@ public class Attr extends JCTree.Visitor {
if (clazztype.tag == CLASS) { if (clazztype.tag == CLASS) {
List<Type> formals = clazztype.tsym.type.getTypeArguments(); List<Type> formals = clazztype.tsym.type.getTypeArguments();
if (actuals.length() == formals.length()) { if (actuals.length() == formals.length() || actuals.length() == 0) {
List<Type> a = actuals; List<Type> a = actuals;
List<Type> f = formals; List<Type> f = formals;
while (a.nonEmpty()) { while (a.nonEmpty()) {
@ -2788,9 +2938,12 @@ public class Attr extends JCTree.Visitor {
// Validate type parameters, supertype and interfaces. // Validate type parameters, supertype and interfaces.
attribBounds(tree.typarams); attribBounds(tree.typarams);
if (!c.isAnonymous()) {
//already checked if anonymous
chk.validate(tree.typarams, env); chk.validate(tree.typarams, env);
chk.validate(tree.extending, env); chk.validate(tree.extending, env);
chk.validate(tree.implementing, env); chk.validate(tree.implementing, env);
}
// If this is a non-abstract class, check that it has no abstract // If this is a non-abstract class, check that it has no abstract
// methods or unimplemented methods of an implemented interface. // methods or unimplemented methods of an implemented interface.

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

@ -640,6 +640,43 @@ public class Check {
return true; return true;
} }
/** Check that the type inferred using the diamond operator does not contain
* non-denotable types such as captured types or intersection types.
* @param t the type inferred using the diamond operator
*/
List<Type> checkDiamond(ClassType t) {
DiamondTypeChecker dtc = new DiamondTypeChecker();
ListBuffer<Type> buf = ListBuffer.lb();
for (Type arg : t.getTypeArguments()) {
if (!dtc.visit(arg, null)) {
buf.append(arg);
}
}
return buf.toList();
}
static class DiamondTypeChecker extends Types.SimpleVisitor<Boolean, Void> {
public Boolean visitType(Type t, Void s) {
return true;
}
@Override
public Boolean visitClassType(ClassType t, Void s) {
if (t.isCompound()) {
return false;
}
for (Type targ : t.getTypeArguments()) {
if (!visit(targ, s)) {
return false;
}
}
return true;
}
@Override
public Boolean visitCapturedType(CapturedType t, Void s) {
return false;
}
}
/** Check that given modifiers are legal for given symbol and /** Check that given modifiers are legal for given symbol and
* return modifiers together with any implicit modififiers for that symbol. * return modifiers together with any implicit modififiers for that symbol.
* Warning: we can't use flags() here since this method * Warning: we can't use flags() here since this method

44
langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java
View file

@ -788,6 +788,8 @@ public class Resolve {
operator); operator);
} }
} }
if (name == names.init)
break;
//- System.out.println(" - " + bestSoFar); //- System.out.println(" - " + bestSoFar);
if (abstractok) { if (abstractok) {
Symbol concrete = methodNotFound; Symbol concrete = methodNotFound;
@ -1409,6 +1411,48 @@ public class Resolve {
return sym; return sym;
} }
/** Resolve constructor using diamond inference.
* @param pos The position to use for error reporting.
* @param env The environment current at the constructor invocation.
* @param site The type of class for which a constructor is searched.
* The scope of this class has been touched in attribution.
* @param argtypes The types of the constructor invocation's value
* arguments.
* @param typeargtypes The types of the constructor invocation's type
* arguments.
*/
Symbol resolveDiamond(DiagnosticPosition pos,
Env<AttrContext> env,
Type site,
List<Type> argtypes,
List<Type> typeargtypes, boolean reportErrors) {
Symbol sym = methodNotFound;
JCDiagnostic explanation = null;
List<MethodResolutionPhase> steps = methodResolutionSteps;
while (steps.nonEmpty() &&
steps.head.isApplicable(boxingEnabled, varargsEnabled) &&
sym.kind >= ERRONEOUS) {
sym = resolveConstructor(pos, env, site, argtypes, typeargtypes,
steps.head.isBoxingRequired(),
env.info.varArgs = steps.head.isVarargsRequired());
methodResolutionCache.put(steps.head, sym);
if (sym.kind == WRONG_MTH &&
((InapplicableSymbolError)sym).explanation != null) {
//if the symbol is an inapplicable method symbol, then the
//explanation contains the reason for which inference failed
explanation = ((InapplicableSymbolError)sym).explanation;
}
steps = steps.tail;
}
if (sym.kind >= AMBIGUOUS && reportErrors) {
String key = explanation == null ?
"cant.apply.diamond" :
"cant.apply.diamond.1";
log.error(pos, key, diags.fragment("diamond", site.tsym), explanation);
}
return sym;
}
/** Resolve constructor. /** Resolve constructor.
* @param pos The position to use for error reporting. * @param pos The position to use for error reporting.
* @param env The environment current at the constructor invocation. * @param env The environment current at the constructor invocation.

30
langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java
View file

@ -131,6 +131,7 @@ public class JavacParser implements Parser {
this.allowForeach = source.allowForeach(); this.allowForeach = source.allowForeach();
this.allowStaticImport = source.allowStaticImport(); this.allowStaticImport = source.allowStaticImport();
this.allowAnnotations = source.allowAnnotations(); this.allowAnnotations = source.allowAnnotations();
this.allowDiamond = source.allowDiamond();
this.allowTypeAnnotations = source.allowTypeAnnotations(); this.allowTypeAnnotations = source.allowTypeAnnotations();
this.keepDocComments = keepDocComments; this.keepDocComments = keepDocComments;
if (keepDocComments) if (keepDocComments)
@ -148,6 +149,10 @@ public class JavacParser implements Parser {
*/ */
boolean allowGenerics; boolean allowGenerics;
/** Switch: Should diamond operator be recognized?
*/
boolean allowDiamond;
/** Switch: Should varargs be recognized? /** Switch: Should varargs be recognized?
*/ */
boolean allowVarargs; boolean allowVarargs;
@ -190,10 +195,11 @@ public class JavacParser implements Parser {
* mode = NOPARAMS : no parameters allowed for type * mode = NOPARAMS : no parameters allowed for type
* mode = TYPEARG : type argument * mode = TYPEARG : type argument
*/ */
static final int EXPR = 1; static final int EXPR = 0x1;
static final int TYPE = 2; static final int TYPE = 0x2;
static final int NOPARAMS = 4; static final int NOPARAMS = 0x4;
static final int TYPEARG = 8; static final int TYPEARG = 0x8;
static final int DIAMOND = 0x10;
/** The current mode. /** The current mode.
*/ */
@ -1343,6 +1349,11 @@ public class JavacParser implements Parser {
ListBuffer<JCExpression> args = lb(); ListBuffer<JCExpression> args = lb();
if (S.token() == LT) { if (S.token() == LT) {
S.nextToken(); S.nextToken();
if (S.token() == GT && (mode & DIAMOND) != 0) {
checkDiamond();
S.nextToken();
return List.nil();
}
args.append(((mode & EXPR) == 0) ? typeArgument() : parseType()); args.append(((mode & EXPR) == 0) ? typeArgument() : parseType());
while (S.token() == COMMA) { while (S.token() == COMMA) {
S.nextToken(); S.nextToken();
@ -1516,7 +1527,7 @@ public class JavacParser implements Parser {
t = F.AnnotatedType(newAnnotations, t); t = F.AnnotatedType(newAnnotations, t);
int oldmode = mode; int oldmode = mode;
mode = TYPE; mode = TYPE | DIAMOND;
if (S.token() == LT) { if (S.token() == LT) {
checkGenerics(); checkGenerics();
t = typeArguments(t); t = typeArguments(t);
@ -1569,8 +1580,11 @@ public class JavacParser implements Parser {
JCExpression innerCreator(int newpos, List<JCExpression> typeArgs, JCExpression encl) { JCExpression innerCreator(int newpos, List<JCExpression> typeArgs, JCExpression encl) {
JCExpression t = toP(F.at(S.pos()).Ident(ident())); JCExpression t = toP(F.at(S.pos()).Ident(ident()));
if (S.token() == LT) { if (S.token() == LT) {
int oldmode = mode;
mode |= DIAMOND;
checkGenerics(); checkGenerics();
t = typeArguments(t); t = typeArguments(t);
mode = oldmode;
} }
return classCreatorRest(newpos, encl, typeArgs, t); return classCreatorRest(newpos, encl, typeArgs, t);
} }
@ -3173,4 +3187,10 @@ public class JavacParser implements Parser {
allowTypeAnnotations = true; allowTypeAnnotations = true;
} }
} }
void checkDiamond() {
if (!allowDiamond) {
log.error(S.pos(), "diamond.not.supported.in.source", source.name);
allowDiamond = true;
}
}
} }

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

@ -479,6 +479,11 @@ compiler.err.undetermined.type.1=\
type parameters of {0} cannot be determined; {1} type parameters of {0} cannot be determined; {1}
compiler.err.invalid.inferred.types=\ compiler.err.invalid.inferred.types=\
invalid inferred types for {0}; {1} invalid inferred types for {0}; {1}
compiler.err.cant.apply.diamond=\
cannot infer type arguments for {0}
compiler.err.cant.apply.diamond.1=\
cannot infer type arguments for {0};\n\
reason: {1}
compiler.err.unreachable.stmt=\ compiler.err.unreachable.stmt=\
unreachable statement unreachable statement
compiler.err.initializer.must.be.able.to.complete.normally=\ compiler.err.initializer.must.be.able.to.complete.normally=\
@ -1030,7 +1035,12 @@ compiler.misc.inferred.do.not.conform.to.params=\
actual arguments do not conform to inferred formal arguments\n\ actual arguments do not conform to inferred formal arguments\n\
required: {0}\n\ required: {0}\n\
found: {1} found: {1}
compiler.misc.diamond=\
{0}<>
compiler.misc.diamond.invalid.arg=\
type argument {0} inferred for {1} is not allowed in this context
compiler.misc.diamond.invalid.args=\
type arguments {0} inferred for {1} are not allowed in this context
##### #####
## The first argument ({0}) is a "kindname". ## The first argument ({0}) is a "kindname".
@ -1163,6 +1173,8 @@ compiler.misc.varargs.implement=\
{0} in {1} implements {2} in {3} {0} in {1} implements {2} in {3}
compiler.misc.varargs.clash.with=\ compiler.misc.varargs.clash.with=\
{0} in {1} overrides {2} in {3} {0} in {1} overrides {2} in {3}
compiler.misc.non.denotable.type=\
Non-denotable type {0} not allowed here
######################################## ########################################
# Diagnostics for language feature changes # Diagnostics for language feature changes

9
langtools/src/share/classes/com/sun/tools/javac/tree/TreeInfo.java
View file

@ -204,6 +204,15 @@ public class TreeInfo {
return (JCMethodInvocation)exec.expr; return (JCMethodInvocation)exec.expr;
} }
/** Return true if a tree represents a diamond new expr. */
public static boolean isDiamond(JCTree tree) {
switch(tree.getTag()) {
case JCTree.TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
case JCTree.NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
default: return false;
}
}
/** Return true if a tree represents the null literal. */ /** Return true if a tree represents the null literal. */
public static boolean isNull(JCTree tree) { public static boolean isNull(JCTree tree) {
if (tree.getTag() != JCTree.LITERAL) if (tree.getTag() != JCTree.LITERAL)

4
langtools/test/tools/javac/6840059/T6840059.out
View file

@ -1,3 +1,3 @@
T6840059.java:15:9: compiler.err.cant.resolve.location.args: kindname.constructor, T6840059, , java.lang.String, kindname.class, T6840059 T6840059.java:15:9: compiler.err.cant.apply.symbol: kindname.constructor, T6840059, java.lang.Integer, java.lang.String, kindname.class, T6840059, null
T6840059.java:15:25: compiler.err.cant.resolve.location.args: kindname.constructor, T6840059, , , kindname.class, T6840059 T6840059.java:15:25: compiler.err.cant.apply.symbol: kindname.constructor, T6840059, java.lang.Integer, compiler.misc.no.args, kindname.class, T6840059, null
2 errors 2 errors

38
langtools/test/tools/javac/generics/diamond/neg/Neg01.java Normal file
View file

@ -0,0 +1,38 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg01.out Neg01.java -XDrawDiagnostics
*
*/
class Neg01<X extends Number> {
Neg01(X x) {}
<Z> Neg01(X x, Z z) {}
void test() {
Neg01<String> n1 = new Neg01<>("");
Neg01<? extends String> n2 = new Neg01<>("");
Neg01<?> n3 = new Neg01<>("");
Neg01<? super String> n4 = new Neg01<>("");
Neg01<String> n5 = new Neg01<>(""){};
Neg01<? extends String> n6 = new Neg01<>(""){};
Neg01<?> n7 = new Neg01<>(""){};
Neg01<? super String> n8 = new Neg01<>(""){};
Neg01<String> n9 = new Neg01<>("", "");
Neg01<? extends String> n10 = new Neg01<>("", "");
Neg01<?> n11 = new Neg01<>("", "");
Foo<? super String> n12 = new Neg01<>("", "");
Neg01<String> n13 = new Neg01<>("", ""){};
Neg01<? extends String> n14 = new Neg01<>("", ""){};
Neg01<?> n15 = new Neg01<>("", ""){};
Neg01<? super String> n16 = new Neg01<>("", ""){};
}
}

29
langtools/test/tools/javac/generics/diamond/neg/Neg01.out Normal file
View file

@ -0,0 +1,29 @@
Neg01.java:18:15: compiler.err.not.within.bounds: java.lang.String
Neg01.java:18:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:19:15: compiler.err.not.within.bounds: ? extends java.lang.String
Neg01.java:19:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:20:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:21:15: compiler.err.not.within.bounds: ? super java.lang.String
Neg01.java:21:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:23:15: compiler.err.not.within.bounds: java.lang.String
Neg01.java:23:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:24:15: compiler.err.not.within.bounds: ? extends java.lang.String
Neg01.java:24:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:25:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:26:15: compiler.err.not.within.bounds: ? super java.lang.String
Neg01.java:26:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:28:15: compiler.err.not.within.bounds: java.lang.String
Neg01.java:28:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:29:15: compiler.err.not.within.bounds: ? extends java.lang.String
Neg01.java:29:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:30:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:31:9: compiler.err.cant.resolve.location: kindname.class, Foo, , , kindname.class, Neg01<X>
Neg01.java:31:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:33:15: compiler.err.not.within.bounds: java.lang.String
Neg01.java:33:29: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:34:15: compiler.err.not.within.bounds: ? extends java.lang.String
Neg01.java:34:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:35:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
Neg01.java:36:15: compiler.err.not.within.bounds: ? super java.lang.String
Neg01.java:36:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg01), null
28 errors

61
langtools/test/tools/javac/generics/diamond/neg/Neg02.java Normal file
View file

@ -0,0 +1,61 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg02.out Neg02.java -XDrawDiagnostics
*
*/
class Neg02 {
static class Foo<X extends Number> {
Foo(X x) {}
<Z> Foo(X x, Z z) {}
}
void testSimple() {
Foo<String> f1 = new Foo<>("");
Foo<? extends String> f2 = new Foo<>("");
Foo<?> f3 = new Foo<>("");
Foo<? super String> f4 = new Foo<>("");
Foo<String> f5 = new Foo<>(""){};
Foo<? extends String> f6 = new Foo<>(""){};
Foo<?> f7 = new Foo<>(""){};
Foo<? super String> f8 = new Foo<>(""){};
Foo<String> f9 = new Foo<>("", "");
Foo<? extends String> f10 = new Foo<>("", "");
Foo<?> f11 = new Foo<>("", "");
Foo<? super String> f12 = new Foo<>("", "");
Foo<String> f13 = new Foo<>("", ""){};
Foo<? extends String> f14 = new Foo<>("", ""){};
Foo<?> f15 = new Foo<>("", ""){};
Foo<? super String> f16 = new Foo<>("", ""){};
}
void testQualified() {
Foo<String> f1 = new Neg02.Foo<>("");
Foo<? extends String> f2 = new Neg02.Foo<>("");
Foo<?> f3 = new Neg02.Foo<>("");
Foo<? super String> f4 = new Neg02.Foo<>("");
Foo<String> f5 = new Neg02.Foo<>(""){};
Foo<? extends String> f6 = new Neg02.Foo<>(""){};
Foo<?> f7 = new Neg02.Foo<>(""){};
Foo<? super String> f8 = new Neg02.Foo<>(""){};
Foo<String> f9 = new Neg02.Foo<>("", "");
Foo<? extends String> f10 = new Neg02.Foo<>("", "");
Foo<?> f11 = new Neg02.Foo<>("", "");
Foo<? super String> f12 = new Neg02.Foo<>("", "");
Foo<String> f13 = new Neg02.Foo<>("", ""){};
Foo<? extends String> f14 = new Neg02.Foo<>("", ""){};
Foo<?> f15 = new Neg02.Foo<>("", ""){};
Foo<? super String> f16 = new Neg02.Foo<>("", ""){};
}
}

57
langtools/test/tools/javac/generics/diamond/neg/Neg02.out Normal file
View file

@ -0,0 +1,57 @@
Neg02.java:19:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:19:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:20:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:20:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:21:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:22:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:22:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:24:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:24:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:25:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:25:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:26:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:27:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:27:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:29:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:29:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:30:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:30:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:31:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:32:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:32:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:34:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:34:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:35:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:35:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:36:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:37:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:37:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:41:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:41:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:42:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:42:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:43:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:44:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:44:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:46:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:46:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:47:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:47:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:48:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:49:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:49:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:51:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:51:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:52:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:52:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:53:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:54:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:54:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:56:13: compiler.err.not.within.bounds: java.lang.String
Neg02.java:56:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:57:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg02.java:57:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:58:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
Neg02.java:59:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg02.java:59:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg02.Foo), null
56 errors

83
langtools/test/tools/javac/generics/diamond/neg/Neg03.java Normal file
View file

@ -0,0 +1,83 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg03.out Neg03.java -XDrawDiagnostics
*
*/
class Neg03<U> {
class Foo<V extends Number> {
Foo(V x) {}
<Z> Foo(V x, Z z) {}
}
void testSimple() {
Foo<String> f1 = new Foo<>("");
Foo<? extends String> f2 = new Foo<>("");
Foo<?> f3 = new Foo<>("");
Foo<? super String> f4 = new Foo<>("");
Foo<String> f5 = new Foo<>(""){};
Foo<? extends String> f6 = new Foo<>(""){};
Foo<?> f7 = new Foo<>(""){};
Foo<? super String> f8 = new Foo<>(""){};
Foo<String> f9 = new Foo<>("", "");
Foo<? extends String> f10 = new Foo<>("", "");
Foo<?> f11 = new Foo<>("", "");
Foo<? super String> f12 = new Foo<>("", "");
Foo<String> f13 = new Foo<>("", ""){};
Foo<? extends String> f14 = new Foo<>("", ""){};
Foo<?> f15 = new Foo<>("", ""){};
Foo<? super String> f16 = new Foo<>("", ""){};
}
void testQualified_1() {
Foo<String> f1 = new Neg03<U>.Foo<>("");
Foo<? extends String> f2 = new Neg03<U>.Foo<>("");
Foo<?> f3 = new Neg03<U>.Foo<>("");
Foo<? super String> f4 = new Neg03<U>.Foo<>("");
Foo<String> f5 = new Neg03<U>.Foo<>(""){};
Foo<? extends String> f6 = new Neg03<U>.Foo<>(""){};
Foo<?> f7 = new Neg03<U>.Foo<>(""){};
Foo<? super String> f8 = new Neg03<U>.Foo<>(""){};
Foo<String> f9 = new Neg03<U>.Foo<>("", "");
Foo<? extends String> f10 = new Neg03<U>.Foo<>("", "");
Foo<?> f11 = new Neg03<U>.Foo<>("", "");
Foo<? super String> f12 = new Neg03<U>.Foo<>("", "");
Foo<String> f13 = new Neg03<U>.Foo<>("", ""){};
Foo<? extends String> f14 = new Neg03<U>.Foo<>("", ""){};
Foo<?> f15 = new Neg03<U>.Foo<>("", ""){};
Foo<? super String> f16 = new Neg03<U>.Foo<>("", ""){};
}
void testQualified_2(Neg03<U> n) {
Foo<String> f1 = n.new Foo<>("");
Foo<? extends String> f2 = n.new Foo<>("");
Foo<?> f3 = n.new Foo<>("");
Foo<? super String> f4 = n.new Foo<>("");
Foo<String> f5 = n.new Foo<>(""){};
Foo<? extends String> f6 = n.new Foo<>(""){};
Foo<?> f7 = n.new Foo<>(""){};
Foo<? super String> f8 = n.new Foo<>(""){};
Foo<String> f9 = n.new Foo<>("", "");
Foo<? extends String> f10 = n.new Foo<>("", "");
Foo<?> f11 = n.new Foo<>("", "");
Foo<? super String> f12 = n.new Foo<>("", "");
Foo<String> f13 = n.new Foo<>("", ""){};
Foo<? extends String> f14 = n.new Foo<>("", ""){};
Foo<?> f15 = n.new Foo<>("", ""){};
Foo<? super String> f16 = n.new Foo<>("", ""){};
}
}

85
langtools/test/tools/javac/generics/diamond/neg/Neg03.out Normal file
View file

@ -0,0 +1,85 @@
Neg03.java:19:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:19:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:20:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:20:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:21:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:22:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:22:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:24:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:24:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:25:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:25:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:26:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:27:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:27:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:29:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:29:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:30:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:30:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:31:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:32:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:32:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:34:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:34:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:35:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:35:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:36:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:37:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:37:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:41:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:41:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:42:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:42:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:43:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:44:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:44:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:46:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:46:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:47:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:47:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:48:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:49:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:49:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:51:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:51:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:52:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:52:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:53:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:54:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:54:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:56:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:56:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:57:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:57:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:58:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:59:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:59:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:63:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:63:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:64:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:64:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:65:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:66:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:66:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:68:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:68:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:69:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:69:38: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:70:23: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:71:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:71:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:73:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:73:28: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:74:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:74:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:75:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:76:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:76:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:78:13: compiler.err.not.within.bounds: java.lang.String
Neg03.java:78:29: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:79:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg03.java:79:39: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:80:24: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
Neg03.java:81:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg03.java:81:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Neg03.Foo), null
84 errors

38
langtools/test/tools/javac/generics/diamond/neg/Neg04.java Normal file
View file

@ -0,0 +1,38 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg04.out Neg04.java -XDrawDiagnostics
*
*/
class Neg04 {
void test() {
class Foo<V extends Number> {
Foo(V x) {}
<Z> Foo(V x, Z z) {}
}
Foo<String> n1 = new Foo<>("");
Foo<? extends String> n2 = new Foo<>("");
Foo<?> n3 = new Foo<>("");
Foo<? super String> n4 = new Foo<>("");
Foo<String> n5 = new Foo<>(""){};
Foo<? extends String> n6 = new Foo<>(""){};
Foo<?> n7 = new Foo<>(""){};
Foo<? super String> n8 = new Foo<>(""){};
Foo<String> n9 = new Foo<>("", "");
Foo<? extends String> n10 = new Foo<>("", "");
Foo<?> n11 = new Foo<>("", "");
Foo<? super String> n12 = new Foo<>("", "");
Foo<String> n13 = new Foo<>("", ""){};
Foo<? extends String> n14 = new Foo<>("", ""){};
Foo<?> n15 = new Foo<>("", ""){};
Foo<? super String> n16 = new Foo<>("", ""){};
}
}

29
langtools/test/tools/javac/generics/diamond/neg/Neg04.out Normal file
View file

@ -0,0 +1,29 @@
Neg04.java:18:13: compiler.err.not.within.bounds: java.lang.String
Neg04.java:18:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:19:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg04.java:19:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:20:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:21:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg04.java:21:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:23:13: compiler.err.not.within.bounds: java.lang.String
Neg04.java:23:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:24:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg04.java:24:36: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:25:21: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:26:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg04.java:26:34: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:28:13: compiler.err.not.within.bounds: java.lang.String
Neg04.java:28:26: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:29:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg04.java:29:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:30:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:31:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg04.java:31:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:33:13: compiler.err.not.within.bounds: java.lang.String
Neg04.java:33:27: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:34:13: compiler.err.not.within.bounds: ? extends java.lang.String
Neg04.java:34:37: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:35:22: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
Neg04.java:36:13: compiler.err.not.within.bounds: ? super java.lang.String
Neg04.java:36:35: compiler.err.cant.apply.diamond: (compiler.misc.diamond: Foo), null
28 errors

61
langtools/test/tools/javac/generics/diamond/neg/Neg05.java Normal file
View file

@ -0,0 +1,61 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg05.out Neg05.java -XDrawDiagnostics
*
*/
class Neg05<U> {
class Foo<V> {
Foo(V x) {}
<Z> Foo(V x, Z z) {}
}
void testRare_1() {
Neg05<?>.Foo<String> f1 = new Neg05.Foo<>("");
Neg05<?>.Foo<? extends String> f2 = new Neg05.Foo<>("");
Neg05<?>.Foo<?> f3 = new Neg05.Foo<>("");
Neg05<?>.Foo<? super String> f4 = new Neg05.Foo<>("");
Neg05<?>.Foo<String> f5 = new Neg05.Foo<>(""){};
Neg05<?>.Foo<? extends String> f6 = new Neg05.Foo<>(""){};
Neg05<?>.Foo<?> f7 = new Neg05.Foo<>(""){};
Neg05<?>.Foo<? super String> f8 = new Neg05.Foo<>(""){};
Neg05<?>.Foo<String> f9 = new Neg05.Foo<>("", "");
Neg05<?>.Foo<? extends String> f10 = new Neg05.Foo<>("", "");
Neg05<?>.Foo<?> f11 = new Neg05.Foo<>("", "");
Neg05<?>.Foo<? super String> f12 = new Neg05.Foo<>("", "");
Neg05<?>.Foo<String> f13 = new Neg05.Foo<>("", ""){};
Neg05<?>.Foo<? extends String> f14 = new Neg05.Foo<>("", ""){};
Neg05<?>.Foo<?> f15 = new Neg05.Foo<>("", ""){};
Neg05<?>.Foo<? super String> f16 = new Neg05.Foo<>("", ""){};
}
void testRare_2(Neg05 n) {
Neg05<?>.Foo<String> f1 = n.new Foo<>("");
Neg05<?>.Foo<? extends String> f2 = n.new Foo<>("");
Neg05<?>.Foo<?> f3 = n.new Foo<>("");
Neg05<?>.Foo<? super String> f4 = n.new Foo<>("");
Neg05<?>.Foo<String> f5 = n.new Foo<>(""){};
Neg05<?>.Foo<? extends String> f6 = n.new Foo<>(""){};
Neg05<?>.Foo<?> f7 = n.new Foo<>(""){};
Neg05<?>.Foo<? super String> f8 = n.new Foo<>(""){};
Neg05<?>.Foo<String> f9 = n.new Foo<>("", "");
Neg05<?>.Foo<? extends String> f10 = n.new Foo<>("", "");
Neg05<?>.Foo<?> f11 = n.new Foo<>("", "");
Neg05<?>.Foo<? super String> f12 = n.new Foo<>("", "");
Neg05<?>.Foo<String> f13 = n.new Foo<>("", ""){};
Neg05<?>.Foo<? extends String> f14 = n.new Foo<>("", ""){};
Neg05<?>.Foo<?> f15 = n.new Foo<>("", ""){};
Neg05<?>.Foo<? super String> f16 = n.new Foo<>("", ""){};
}
}

49
langtools/test/tools/javac/generics/diamond/neg/Neg05.out Normal file
View file

@ -0,0 +1,49 @@
Neg05.java:19:48: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:19:35: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<java.lang.String>
Neg05.java:20:58: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:20:45: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? extends java.lang.String>
Neg05.java:21:43: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:21:30: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<?>
Neg05.java:22:56: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:22:43: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? super java.lang.String>
Neg05.java:24:48: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:24:35: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<java.lang.String>
Neg05.java:25:58: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:25:45: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? extends java.lang.String>
Neg05.java:26:43: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:26:30: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<?>
Neg05.java:27:56: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:27:43: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? super java.lang.String>
Neg05.java:29:48: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:29:35: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<java.lang.String>
Neg05.java:30:59: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:30:46: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? extends java.lang.String>
Neg05.java:31:44: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:31:31: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<?>
Neg05.java:32:57: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:32:44: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? super java.lang.String>
Neg05.java:34:49: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:34:36: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<java.lang.String>
Neg05.java:35:59: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:35:46: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? extends java.lang.String>
Neg05.java:36:44: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:36:31: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<?>
Neg05.java:37:57: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:37:44: compiler.err.prob.found.req: (compiler.misc.incompatible.types), compiler.misc.anonymous.class: Neg05.Foo<java.lang.String>, Neg05<?>.Foo<? super java.lang.String>
Neg05.java:41:37: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:42:47: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:43:32: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:44:45: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:46:37: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:47:47: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:48:32: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:49:45: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:51:37: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:52:48: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:53:33: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:54:46: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:56:38: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:57:48: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:58:33: compiler.err.improperly.formed.type.inner.raw.param
Neg05.java:59:46: compiler.err.improperly.formed.type.inner.raw.param
48 errors

21
langtools/test/tools/javac/generics/diamond/neg/Neg06.java Normal file
View file

@ -0,0 +1,21 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg06.out Neg06.java -XDrawDiagnostics
*
*/
class Neg06 {
interface ISuperFoo<X> {}
interface IFoo<X extends Number> extends ISuperFoo<X> {}
static class CSuperFoo<X> {}
static class CFoo<X extends Number> extends CSuperFoo<X> {}
ISuperFoo<String> isf = new IFoo<>() {};
CSuperFoo<String> csf1 = new CFoo<>();
CSuperFoo<String> csf2 = new CFoo<>() {};
}

4
langtools/test/tools/javac/generics/diamond/neg/Neg06.out Normal file
View file

@ -0,0 +1,4 @@
Neg06.java:18:36: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.IFoo), (compiler.misc.no.conforming.instance.exists: X, Neg06.IFoo<X>, Neg06.ISuperFoo<java.lang.String>)
Neg06.java:19:37: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.no.conforming.instance.exists: X, Neg06.CFoo<X>, Neg06.CSuperFoo<java.lang.String>)
Neg06.java:20:37: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg06.CFoo), (compiler.misc.no.conforming.instance.exists: X, Neg06.CFoo<X>, Neg06.CSuperFoo<java.lang.String>)
3 errors

19
langtools/test/tools/javac/generics/diamond/neg/Neg07.java Normal file
View file

@ -0,0 +1,19 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg07.out Neg07.java -XDrawDiagnostics
*
*/
class Neg07 {
static class SuperFoo<X> {}
static class Foo<X extends Number> extends SuperFoo<X> {
Foo(X x) {}
}
SuperFoo<String> sf1 = new Foo<>("");
SuperFoo<String> sf2 = new Foo<>("") {};
}

3
langtools/test/tools/javac/generics/diamond/neg/Neg07.out Normal file
View file

@ -0,0 +1,3 @@
Neg07.java:17:27: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg07.Foo), (compiler.misc.inferred.do.not.conform.to.bounds: java.lang.String, java.lang.Number)
Neg07.java:18:27: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg07.Foo), (compiler.misc.inferred.do.not.conform.to.bounds: java.lang.String, java.lang.Number)
2 errors

30
langtools/test/tools/javac/generics/diamond/neg/Neg08.java Normal file
View file

@ -0,0 +1,30 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620 6894753
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg08.out Neg08.java -XDrawDiagnostics
*
*/
class Neg08 {
static class Foo<X> {
Foo(X x) { }
}
static class DoubleFoo<X,Y> {
DoubleFoo(X x,Y y) { }
}
static class TripleFoo<X,Y,Z> {
TripleFoo(X x,Y y,Z z) { }
}
Foo<? extends Integer> fi = new Foo<>(1);
Foo<?> fw = new Foo<>(fi);
Foo<? extends Double> fd = new Foo<>(3.0);
DoubleFoo<?,?> dw = new DoubleFoo<>(fi,fd);
Foo<String> fs = new Foo<>("one");
TripleFoo<?,?,?> tw = new TripleFoo<>(fi,fd,fs);
}

4
langtools/test/tools/javac/generics/diamond/neg/Neg08.out Normal file
View file

@ -0,0 +1,4 @@
Neg08.java:25:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg08.Foo), (compiler.misc.diamond.invalid.arg: Neg08.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>, (compiler.misc.diamond: Neg08.Foo))
Neg08.java:27:38: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg08.DoubleFoo), (compiler.misc.diamond.invalid.args: Neg08.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>,Neg08.Foo<compiler.misc.type.captureof: 2, ? extends java.lang.Double>, (compiler.misc.diamond: Neg08.DoubleFoo))
Neg08.java:29:40: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg08.TripleFoo), (compiler.misc.diamond.invalid.args: Neg08.Foo<compiler.misc.type.captureof: 1, ? extends java.lang.Integer>,Neg08.Foo<compiler.misc.type.captureof: 2, ? extends java.lang.Double>, (compiler.misc.diamond: Neg08.TripleFoo))
3 errors

22
langtools/test/tools/javac/generics/diamond/neg/Neg09.java Normal file
View file

@ -0,0 +1,22 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620 6894753
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg09.out Neg09.java -XDrawDiagnostics
*
*/
class Neg09 {
static class Foo<X extends Number & Comparable<Number>> {}
static class DoubleFoo<X extends Number & Comparable<Number>,
Y extends Number & Comparable<Number>> {}
static class TripleFoo<X extends Number & Comparable<Number>,
Y extends Number & Comparable<Number>,
Z> {}
Foo<?> fw = new Foo<>();
DoubleFoo<?,?> dw = new DoubleFoo<>();
TripleFoo<?,?,?> tw = new TripleFoo<>();
}

4
langtools/test/tools/javac/generics/diamond/neg/Neg09.out Normal file
View file

@ -0,0 +1,4 @@
Neg09.java:19:24: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg09.Foo), (compiler.misc.diamond.invalid.arg: java.lang.Number&java.lang.Comparable<java.lang.Number>, (compiler.misc.diamond: Neg09.Foo))
Neg09.java:20:38: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg09.DoubleFoo), (compiler.misc.diamond.invalid.args: java.lang.Number&java.lang.Comparable<java.lang.Number>,java.lang.Number&java.lang.Comparable<java.lang.Number>, (compiler.misc.diamond: Neg09.DoubleFoo))
Neg09.java:21:40: compiler.err.cant.apply.diamond.1: (compiler.misc.diamond: Neg09.TripleFoo), (compiler.misc.diamond.invalid.args: java.lang.Number&java.lang.Comparable<java.lang.Number>,java.lang.Number&java.lang.Comparable<java.lang.Number>, (compiler.misc.diamond: Neg09.TripleFoo))
3 errors

17
langtools/test/tools/javac/generics/diamond/neg/Neg10.java Normal file
View file

@ -0,0 +1,17 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg10.out Neg10.java -XDrawDiagnostics
*
*/
class Neg10 {
static class Foo<X> {
Foo(X x) {}
}
Foo<Number> fw = new Foo<>(1);
}

2
langtools/test/tools/javac/generics/diamond/neg/Neg10.out Normal file
View file

@ -0,0 +1,2 @@
Neg10.java:16:22: compiler.err.prob.found.req: (compiler.misc.incompatible.types), Neg10.Foo<java.lang.Integer>, Neg10.Foo<java.lang.Number>
1 error

18
langtools/test/tools/javac/generics/diamond/neg/Neg11.java Normal file
View file

@ -0,0 +1,18 @@
/*
* @test /nodynamiccopyright/
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile/fail/ref=Neg11.out Neg11.java -XDrawDiagnostics
*
*/
class Neg11 {
void test() {
class Foo<X extends Number> { }
Foo<?> f1 = new UndeclaredName<>(); //this is deliberate: aim is to test erroneous path
Foo<?> f2 = new UndeclaredName<>() {}; //this is deliberate: aim is to test erroneous path
}
}

3
langtools/test/tools/javac/generics/diamond/neg/Neg11.out Normal file
View file

@ -0,0 +1,3 @@
Neg11.java:15:25: compiler.err.cant.resolve.location: kindname.class, UndeclaredName, , , kindname.class, Neg11
Neg11.java:16:25: compiler.err.cant.resolve.location: kindname.class, UndeclaredName, , , kindname.class, Neg11
2 errors

67
langtools/test/tools/javac/generics/diamond/pos/Pos01.java Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* @test
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile Pos01.java
* @run main Pos01
*
*/
public class Pos01<X> {
Pos01(X x) {}
<Z> Pos01(X x, Z z) {}
void test() {
Pos01<Integer> p1 = new Pos01<>(1);
Pos01<? extends Integer> p2 = new Pos01<>(1);
Pos01<?> p3 = new Pos01<>(1);
Pos01<? super Integer> p4 = new Pos01<>(1);
Pos01<Integer> p5 = new Pos01<>(1){};
Pos01<? extends Integer> p6 = new Pos01<>(1){};
Pos01<?> p7 = new Pos01<>(1){};
Pos01<? super Integer> p8 = new Pos01<>(1){};
Pos01<Integer> p9 = new Pos01<>(1, "");
Pos01<? extends Integer> p10 = new Pos01<>(1, "");
Pos01<?> p11 = new Pos01<>(1, "");
Pos01<? super Integer> p12 = new Pos01<>(1, "");
Pos01<Integer> p13 = new Pos01<>(1, ""){};
Pos01<? extends Integer> p14= new Pos01<>(1, ""){};
Pos01<?> p15 = new Pos01<>(1, ""){};
Pos01<? super Integer> p16 = new Pos01<>(1, ""){};
}
public static void main(String[] args) {
Pos01<String> p1 = new Pos01<>("");
p1.test();
}
}

90
langtools/test/tools/javac/generics/diamond/pos/Pos02.java Normal file
View file

@ -0,0 +1,90 @@
/*
* Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* @test
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile Pos02.java
* @run main Pos02
*/
public class Pos02 {
static class Foo<X> {
Foo(X x) {}
<Z> Foo(X x, Z z) {}
}
void testSimple() {
Foo<Integer> f1 = new Foo<>(1);
Foo<? extends Integer> f2 = new Foo<>(1);
Foo<?> f3 = new Foo<>(1);
Foo<? super Integer> f4 = new Foo<>(1);
Foo<Integer> f5 = new Foo<>(1){};
Foo<? extends Integer> f6 = new Foo<>(1){};
Foo<?> f7 = new Foo<>(1){};
Foo<? super Integer> f8 = new Foo<>(1){};
Foo<Integer> f9 = new Foo<>(1, "");
Foo<? extends Integer> f10 = new Foo<>(1, "");
Foo<?> f11 = new Foo<>(1, "");
Foo<? super Integer> f12 = new Foo<>(1, "");
Foo<Integer> f13 = new Foo<>(1, ""){};
Foo<? extends Integer> f14 = new Foo<>(1, ""){};
Foo<?> f15 = new Foo<>(1, ""){};
Foo<? super Integer> f16 = new Foo<>(1, ""){};
}
void testQualified() {
Foo<Integer> f1 = new Pos02.Foo<>(1);
Foo<? extends Integer> f2 = new Pos02.Foo<>(1);
Foo<?> f3 = new Pos02.Foo<>(1);
Foo<? super Integer> f4 = new Pos02.Foo<>(1);
Foo<Integer> f5 = new Pos02.Foo<>(1){};
Foo<? extends Integer> f6 = new Pos02.Foo<>(1){};
Foo<?> f7 = new Pos02.Foo<>(1){};
Foo<? super Integer> f8 = new Pos02.Foo<>(1){};
Foo<Integer> f9 = new Pos02.Foo<>(1, "");
Foo<? extends Integer> f10 = new Pos02.Foo<>(1, "");
Foo<?> f11 = new Pos02.Foo<>(1, "");
Foo<? super Integer> f12 = new Pos02.Foo<>(1, "");
Foo<Integer> f13 = new Pos02.Foo<>(1, ""){};
Foo<? extends Integer> f14 = new Pos02.Foo<>(1, ""){};
Foo<?> f15 = new Pos02.Foo<>(1, ""){};
Foo<? super Integer> f16 = new Pos02.Foo<>(1, ""){};
}
public static void main(String[] args) {
Pos02 p2 = new Pos02();
p2.testSimple();
p2.testQualified();
}
}

114
langtools/test/tools/javac/generics/diamond/pos/Pos03.java Normal file
View file

@ -0,0 +1,114 @@
/*
* Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* @test
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile Pos03.java
* @run main Pos03
*
*/
public class Pos03<U> {
class Foo<V> {
Foo(V x) {}
<Z> Foo(V x, Z z) {}
}
void testSimple() {
Foo<Integer> f1 = new Foo<>(1);
Foo<? extends Integer> f2 = new Foo<>(1);
Foo<?> f3 = new Foo<>(1);
Foo<? super Integer> f4 = new Foo<>(1);
Foo<Integer> f5 = new Foo<>(1){};
Foo<? extends Integer> f6 = new Foo<>(1){};
Foo<?> f7 = new Foo<>(1){};
Foo<? super Integer> f8 = new Foo<>(1){};
Foo<Integer> f9 = new Foo<>(1, "");
Foo<? extends Integer> f10 = new Foo<>(1, "");
Foo<?> f11 = new Foo<>(1, "");
Foo<? super Integer> f12 = new Foo<>(1, "");
Foo<Integer> f13 = new Foo<>(1, ""){};
Foo<? extends Integer> f14 = new Foo<>(1, ""){};
Foo<?> f15 = new Foo<>(1, ""){};
Foo<? super Integer> f16 = new Foo<>(1, ""){};
}
void testQualified_1() {
Foo<Integer> f1 = new Pos03<U>.Foo<>(1);
Foo<? extends Integer> f2 = new Pos03<U>.Foo<>(1);
Foo<?> f3 = new Pos03<U>.Foo<>(1);
Foo<? super Integer> f4 = new Pos03<U>.Foo<>(1);
Foo<Integer> f5 = new Pos03<U>.Foo<>(1){};
Foo<? extends Integer> f6 = new Pos03<U>.Foo<>(1){};
Foo<?> f7 = new Pos03<U>.Foo<>(1){};
Foo<? super Integer> f8 = new Pos03<U>.Foo<>(1){};
Foo<Integer> f9 = new Pos03<U>.Foo<>(1, "");
Foo<? extends Integer> f10 = new Pos03<U>.Foo<>(1, "");
Foo<?> f11 = new Pos03<U>.Foo<>(1, "");
Foo<? super Integer> f12 = new Pos03<U>.Foo<>(1, "");
Foo<Integer> f13 = new Pos03<U>.Foo<>(1, ""){};
Foo<? extends Integer> f14 = new Pos03<U>.Foo<>(1, ""){};
Foo<?> f15 = new Pos03<U>.Foo<>(1, ""){};
Foo<? super Integer> f16 = new Pos03<U>.Foo<>(1, ""){};
}
void testQualified_2(Pos03<U> p) {
Foo<Integer> f1 = p.new Foo<>(1);
Foo<? extends Integer> f2 = p.new Foo<>(1);
Foo<?> f3 = p.new Foo<>(1);
Foo<? super Integer> f4 = p.new Foo<>(1);
Foo<Integer> f5 = p.new Foo<>(1){};
Foo<? extends Integer> f6 = p.new Foo<>(1){};
Foo<?> f7 = p.new Foo<>(1){};
Foo<? super Integer> f8 = p.new Foo<>(1){};
Foo<Integer> f9 = p.new Foo<>(1, "");
Foo<? extends Integer> f10 = p.new Foo<>(1, "");
Foo<?> f11 = p.new Foo<>(1, "");
Foo<? super Integer> f12 = p.new Foo<>(1, "");
Foo<Integer> f13 = p.new Foo<>(1, ""){};
Foo<? extends Integer> f14 = p.new Foo<>(1, ""){};
Foo<?> f15 = p.new Foo<>(1, ""){};
Foo<? super Integer> f16 = p.new Foo<>(1, ""){};
}
public static void main(String[] args) {
Pos03<String> p3 = new Pos03<>();
p3.testSimple();
p3.testQualified_1();
p3.testQualified_2(p3);
}
}

67
langtools/test/tools/javac/generics/diamond/pos/Pos04.java Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* @test
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile Pos04.java
* @run main Pos04
*
*/
public class Pos04<U> {
void test() {
class Foo<V> {
Foo(V x) {}
<Z> Foo(V x, Z z) {}
}
Foo<Integer> p1 = new Foo<>(1);
Foo<? extends Integer> p2 = new Foo<>(1);
Foo<?> p3 = new Foo<>(1);
Foo<? super Integer> p4 = new Foo<>(1);
Foo<Integer> p5 = new Foo<>(1){};
Foo<? extends Integer> p6 = new Foo<>(1){};
Foo<?> p7 = new Foo<>(1){};
Foo<? super Integer> p8 = new Foo<>(1){};
Foo<Integer> p9 = new Foo<>(1, "");
Foo<? extends Integer> p10 = new Foo<>(1, "");
Foo<?> p11 = new Foo<>(1, "");
Foo<? super Integer> p12 = new Foo<>(1, "");
Foo<Integer> p13 = new Foo<>(1, ""){};
Foo<? extends Integer> p14 = new Foo<>(1, ""){};
Foo<?> p15 = new Foo<>(1, ""){};
Foo<? super Integer> p16 = new Foo<>(1, ""){};
}
public static void main(String[] args) {
Pos04<String> p4 = new Pos04<>();
p4.test();
}
}

45
langtools/test/tools/javac/generics/diamond/pos/Pos05.java Normal file
View file

@ -0,0 +1,45 @@
/*
* Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/*
* @test
* @bug 6939620
*
* @summary Switch to 'complex' diamond inference scheme
* @author mcimadamore
* @compile Pos05.java
*
*/
public class Pos05 {
static class Foo<X> {
Foo(X x) {}
}
void m(Foo<Integer> fi) {}
void test() {
m(new Foo<>(1));
}
}