# HG changeset patch # User tbell # Date 1245820168 25200 # Node ID b75c1c3bfe7210cc40f382da7898581afd1cc569 # Parent 6107cbff3130c747d243c25a7874cd59db5744a8# Parent 79c119fae7fb55b9e7b9919522d09d9b17303d6a Merge diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/classfile/AccessFlags.java --- a/langtools/src/share/classes/com/sun/tools/classfile/AccessFlags.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/classfile/AccessFlags.java Tue Jun 23 22:09:28 2009 -0700 @@ -58,7 +58,7 @@ public static final int ACC_ENUM = 0x4000; // class, inner, field public static final int ACC_MODULE = 0x8000; // class, inner, field, method - private static enum Type { Class, InnerClass, Field, Method}; + public static enum Kind { Class, InnerClass, Field, Method}; AccessFlags(ClassReader cr) throws IOException { this(cr.readUnsignedShort()); @@ -87,11 +87,11 @@ public Set getClassModifiers() { int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags); - return getModifiers(f, classModifiers, Type.Class); + return getModifiers(f, classModifiers, Kind.Class); } public Set getClassFlags() { - return getFlags(classFlags, Type.Class); + return getFlags(classFlags, Kind.Class); } private static final int[] innerClassModifiers = { @@ -106,11 +106,11 @@ public Set getInnerClassModifiers() { int f = ((flags & ACC_INTERFACE) != 0 ? flags & ~ACC_ABSTRACT : flags); - return getModifiers(f, innerClassModifiers, Type.InnerClass); + return getModifiers(f, innerClassModifiers, Kind.InnerClass); } public Set getInnerClassFlags() { - return getFlags(innerClassFlags, Type.InnerClass); + return getFlags(innerClassFlags, Kind.InnerClass); } private static final int[] fieldModifiers = { @@ -124,11 +124,11 @@ }; public Set getFieldModifiers() { - return getModifiers(fieldModifiers, Type.Field); + return getModifiers(fieldModifiers, Kind.Field); } public Set getFieldFlags() { - return getFlags(fieldFlags, Type.Field); + return getFlags(fieldFlags, Kind.Field); } private static final int[] methodModifiers = { @@ -143,18 +143,18 @@ }; public Set getMethodModifiers() { - return getModifiers(methodModifiers, Type.Method); + return getModifiers(methodModifiers, Kind.Method); } public Set getMethodFlags() { - return getFlags(methodFlags, Type.Method); + return getFlags(methodFlags, Kind.Method); } - private Set getModifiers(int[] modifierFlags, Type t) { + private Set getModifiers(int[] modifierFlags, Kind t) { return getModifiers(flags, modifierFlags, t); } - private static Set getModifiers(int flags, int[] modifierFlags, Type t) { + private static Set getModifiers(int flags, int[] modifierFlags, Kind t) { Set s = new LinkedHashSet(); for (int m: modifierFlags) { if ((flags & m) != 0) @@ -163,7 +163,7 @@ return s; } - private Set getFlags(int[] expectedFlags, Type t) { + private Set getFlags(int[] expectedFlags, Kind t) { Set s = new LinkedHashSet(); int f = flags; for (int e: expectedFlags) { @@ -180,7 +180,7 @@ return s; } - private static String flagToModifier(int flag, Type t) { + private static String flagToModifier(int flag, Kind t) { switch (flag) { case ACC_PUBLIC: return "public"; @@ -195,7 +195,7 @@ case ACC_SYNCHRONIZED: return "synchronized"; case 0x80: - return (t == Type.Field ? "transient" : null); + return (t == Kind.Field ? "transient" : null); case ACC_VOLATILE: return "volatile"; case ACC_NATIVE: @@ -211,7 +211,7 @@ } } - private static String flagToName(int flag, Type t) { + private static String flagToName(int flag, Kind t) { switch (flag) { case ACC_PUBLIC: return "ACC_PUBLIC"; @@ -224,11 +224,11 @@ case ACC_FINAL: return "ACC_FINAL"; case 0x20: - return (t == Type.Class ? "ACC_SUPER" : "ACC_SYNCHRONIZED"); + return (t == Kind.Class ? "ACC_SUPER" : "ACC_SYNCHRONIZED"); case 0x40: - return (t == Type.Field ? "ACC_VOLATILE" : "ACC_BRIDGE"); + return (t == Kind.Field ? "ACC_VOLATILE" : "ACC_BRIDGE"); case 0x80: - return (t == Type.Field ? "ACC_TRANSIENT" : "ACC_VARARGS"); + return (t == Kind.Field ? "ACC_TRANSIENT" : "ACC_VARARGS"); case ACC_NATIVE: return "ACC_NATIVE"; case ACC_INTERFACE: @@ -250,5 +250,5 @@ } } - final int flags; + public final int flags; } diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/classfile/ConstantPool.java --- a/langtools/src/share/classes/com/sun/tools/classfile/ConstantPool.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/classfile/ConstantPool.java Tue Jun 23 22:09:28 2009 -0700 @@ -573,6 +573,11 @@ return visitor.visitNameAndType(this, data); } + @Override + public String toString() { + return "CONSTANT_NameAndType_info[name_index: " + name_index + ", type_index: " + type_index + "]"; + } + public final int name_index; public final int type_index; } @@ -600,6 +605,11 @@ return visitor.visitString(this, data); } + @Override + public String toString() { + return "CONSTANT_String_info[class_index: " + string_index + "]"; + } + public final int string_index; } @@ -618,7 +628,19 @@ @Override public String toString() { - return "CONSTANT_Utf8_info[value: " + value + "]"; + if (value.length() < 32 && isPrintableAscii(value)) + return "CONSTANT_Utf8_info[value: \"" + value + "\"]"; + else + return "CONSTANT_Utf8_info[value: (" + value.length() + " chars)]"; + } + + static boolean isPrintableAscii(String s) { + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (c < 32 || c >= 127) + return false; + } + return true; } public R accept(Visitor visitor, D data) { diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/code/Type.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Type.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Type.java Tue Jun 23 22:09:28 2009 -0700 @@ -1066,6 +1066,21 @@ return qtype.isErroneous(); } + /** + * Replaces this ForAll's typevars with a set of concrete Java types + * and returns the instantiated generic type. Subclasses might override + * in order to check that the list of types is a valid instantiation + * of the ForAll's typevars. + * + * @param actuals list of actual types + * @param types types instance + * @return qtype where all occurrences of tvars are replaced + * by types in actuals + */ + public Type inst(List actuals, Types types) { + return types.subst(qtype, tvars, actuals); + } + public Type map(Mapping f) { return f.apply(qtype); } diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/code/Types.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Types.java Tue Jun 23 22:09:28 2009 -0700 @@ -343,6 +343,14 @@ if (s.tag >= firstPartialTag) return isSuperType(s, t); + if (s.isCompound()) { + for (Type s2 : interfaces(s).prepend(supertype(s))) { + if (!isSubtype(t, s2, capture)) + return false; + } + return true; + } + Type lower = lowerBound(s); if (s != lower) return isSubtype(capture ? capture(t) : t, lower, false); @@ -2870,6 +2878,14 @@ /** * Capture conversion as specified by JLS 3rd Ed. */ + + public List capture(List ts) { + List buf = List.nil(); + for (Type t : ts) { + buf = buf.prepend(capture(t)); + } + return buf.reverse(); + } public Type capture(Type t) { if (t.tag != CLASS) return t; diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/comp/Check.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Jun 23 22:09:28 2009 -0700 @@ -391,6 +391,10 @@ diags.fragment("incompatible.types" + (d!=null ? ".1" : ""), d), t, pt); } + } catch (Infer.InvalidInstanceException ex) { + JCDiagnostic d = ex.getDiagnostic(); + log.error(pos, "invalid.inferred.types", t.tvars, d); + return types.createErrorType(pt); } } } diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java Tue Jun 23 22:09:28 2009 -0700 @@ -29,6 +29,7 @@ import com.sun.tools.javac.util.List; import com.sun.tools.javac.code.*; import com.sun.tools.javac.code.Type.*; +import com.sun.tools.javac.code.Symbol.*; import com.sun.tools.javac.util.JCDiagnostic; import static com.sun.tools.javac.code.TypeTags.*; @@ -49,6 +50,7 @@ Symtab syms; Types types; + Resolve rs; JCDiagnostic.Factory diags; public static Infer instance(Context context) { @@ -62,48 +64,60 @@ context.put(inferKey, this); syms = Symtab.instance(context); types = Types.instance(context); + rs = Resolve.instance(context); diags = JCDiagnostic.Factory.instance(context); ambiguousNoInstanceException = new NoInstanceException(true, diags); unambiguousNoInstanceException = new NoInstanceException(false, diags); + invalidInstanceException = + new InvalidInstanceException(diags); + } - public static class NoInstanceException extends RuntimeException { + public static class InferenceException extends RuntimeException { private static final long serialVersionUID = 0; - boolean isAmbiguous; // exist several incomparable best instances? - JCDiagnostic diagnostic; JCDiagnostic.Factory diags; - NoInstanceException(boolean isAmbiguous, JCDiagnostic.Factory diags) { + InferenceException(JCDiagnostic.Factory diags) { this.diagnostic = null; - this.isAmbiguous = isAmbiguous; this.diags = diags; } - NoInstanceException setMessage(String key) { - this.diagnostic = diags.fragment(key); - return this; - } - NoInstanceException setMessage(String key, Object arg1) { - this.diagnostic = diags.fragment(key, arg1); + + InferenceException setMessage(String key, Object... args) { + this.diagnostic = diags.fragment(key, args); return this; } - NoInstanceException setMessage(String key, Object arg1, Object arg2) { - this.diagnostic = diags.fragment(key, arg1, arg2); - return this; - } - NoInstanceException setMessage(String key, Object arg1, Object arg2, Object arg3) { - this.diagnostic = diags.fragment(key, arg1, arg2, arg3); - return this; - } + public JCDiagnostic getDiagnostic() { - return diagnostic; + return diagnostic; + } + } + + public static class NoInstanceException extends InferenceException { + private static final long serialVersionUID = 1; + + boolean isAmbiguous; // exist several incomparable best instances? + + NoInstanceException(boolean isAmbiguous, JCDiagnostic.Factory diags) { + super(diags); + this.isAmbiguous = isAmbiguous; } } + + public static class InvalidInstanceException extends InferenceException { + private static final long serialVersionUID = 2; + + InvalidInstanceException(JCDiagnostic.Factory diags) { + super(diags); + } + } + private final NoInstanceException ambiguousNoInstanceException; private final NoInstanceException unambiguousNoInstanceException; + private final InvalidInstanceException invalidInstanceException; /*************************************************************************** * Auxiliary type values and classes @@ -158,8 +172,7 @@ that.inst = types.glb(that.hibounds); } if (that.inst == null || - that.inst.isErroneous() || - !types.isSubtypeUnchecked(that.inst, that.hibounds, warn)) + that.inst.isErroneous()) throw ambiguousNoInstanceException .setMessage("no.unique.maximal.instance.exists", that.qtype, that.hibounds); @@ -234,7 +247,7 @@ */ public Type instantiateExpr(ForAll that, Type to, - Warner warn) throws NoInstanceException { + Warner warn) throws InferenceException { List undetvars = Type.map(that.tvars, fromTypeVarFun); for (List l = undetvars; l.nonEmpty(); l = l.tail) { UndetVar v = (UndetVar) l.head; @@ -260,8 +273,7 @@ List targs = Type.map(undetvars, getInstFun); targs = types.subst(targs, that.tvars, targs); checkWithinBounds(that.tvars, targs, warn); - - return getInstFun.apply(qtype1); + return that.inst(targs, types); } /** Instantiate method type `mt' by finding instantiations of @@ -269,36 +281,42 @@ */ public Type instantiateMethod(List tvars, MethodType mt, - List argtypes, - boolean allowBoxing, - boolean useVarargs, - Warner warn) throws NoInstanceException { + final List argtypes, + final boolean allowBoxing, + final boolean useVarargs, + final Warner warn) throws InferenceException { //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG List undetvars = Type.map(tvars, fromTypeVarFun); List formals = mt.argtypes; - + //need to capture exactly once - otherwise subsequent + //applicability checks might fail + final List capturedArgs = types.capture(argtypes); + List actuals = capturedArgs; + List actualsNoCapture = argtypes; // instantiate all polymorphic argument types and // set up lower bounds constraints for undetvars Type varargsFormal = useVarargs ? formals.last() : null; - while (argtypes.nonEmpty() && formals.head != varargsFormal) { - Type ft = formals.head; - Type at = argtypes.head.baseType(); - if (at.tag == FORALL) - at = instantiateArg((ForAll) at, ft, tvars, warn); - Type sft = types.subst(ft, tvars, undetvars); + while (actuals.nonEmpty() && formals.head != varargsFormal) { + Type formal = formals.head; + Type actual = actuals.head.baseType(); + Type actualNoCapture = actualsNoCapture.head.baseType(); + if (actual.tag == FORALL) + actual = instantiateArg((ForAll)actual, formal, tvars, warn); + Type undetFormal = types.subst(formal, tvars, undetvars); boolean works = allowBoxing - ? types.isConvertible(at, sft, warn) - : types.isSubtypeUnchecked(at, sft, warn); + ? types.isConvertible(actual, undetFormal, warn) + : types.isSubtypeUnchecked(actual, undetFormal, warn); if (!works) { throw unambiguousNoInstanceException .setMessage("no.conforming.assignment.exists", - tvars, at, ft); + tvars, actualNoCapture, formal); } formals = formals.tail; - argtypes = argtypes.tail; + actuals = actuals.tail; + actualsNoCapture = actualsNoCapture.tail; } if (formals.head != varargsFormal || // not enough args - !useVarargs && argtypes.nonEmpty()) { // too many args + !useVarargs && actuals.nonEmpty()) { // too many args // argument lists differ in length throw unambiguousNoInstanceException .setMessage("arg.length.mismatch"); @@ -306,20 +324,21 @@ // for varargs arguments as well if (useVarargs) { - Type elt = types.elemtype(varargsFormal); - Type sft = types.subst(elt, tvars, undetvars); - while (argtypes.nonEmpty()) { - Type ft = sft; - Type at = argtypes.head.baseType(); - if (at.tag == FORALL) - at = instantiateArg((ForAll) at, ft, tvars, warn); - boolean works = types.isConvertible(at, sft, warn); + Type elemType = types.elemtype(varargsFormal); + Type elemUndet = types.subst(elemType, tvars, undetvars); + while (actuals.nonEmpty()) { + Type actual = actuals.head.baseType(); + Type actualNoCapture = actualsNoCapture.head.baseType(); + if (actual.tag == FORALL) + actual = instantiateArg((ForAll)actual, elemType, tvars, warn); + boolean works = types.isConvertible(actual, elemUndet, warn); if (!works) { throw unambiguousNoInstanceException .setMessage("no.conforming.assignment.exists", - tvars, at, ft); + tvars, actualNoCapture, elemType); } - argtypes = argtypes.tail; + actuals = actuals.tail; + actualsNoCapture = actualsNoCapture.tail; } } @@ -350,16 +369,38 @@ } checkWithinBounds(tvars, undettypes.toList(), warn); + mt = (MethodType)types.subst(mt, tvars, insttypes.toList()); + if (!restvars.isEmpty()) { // if there are uninstantiated variables, // quantify result type with them - mt = new MethodType(mt.argtypes, - new ForAll(restvars.toList(), mt.restype), - mt.thrown, syms.methodClass); + final List inferredTypes = insttypes.toList(); + final List all_tvars = tvars; //this is the wrong tvars + final MethodType mt2 = new MethodType(mt.argtypes, null, mt.thrown, syms.methodClass); + mt2.restype = new ForAll(restvars.toList(), mt.restype) { + @Override + public Type inst(List inferred, Types types) throws NoInstanceException { + List formals = types.subst(mt2.argtypes, tvars, inferred); + if (!rs.argumentsAcceptable(capturedArgs, formals, + allowBoxing, useVarargs, warn)) { + // inferred method is not applicable + throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", formals, argtypes); + } + // check that inferred bounds conform to their bounds + checkWithinBounds(all_tvars, + types.subst(inferredTypes, tvars, inferred), warn); + return super.inst(inferred, types); + }}; + return mt2; } - - // return instantiated version of method type - return types.subst(mt, tvars, insttypes.toList()); + else if (!rs.argumentsAcceptable(capturedArgs, mt.getParameterTypes(), allowBoxing, useVarargs, warn)) { + // inferred method is not applicable + throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", mt.getParameterTypes(), argtypes); + } + else { + // return instantiated version of method type + return mt; + } } //where @@ -371,7 +412,7 @@ private Type instantiateArg(ForAll that, Type to, List tvars, - Warner warn) throws NoInstanceException { + Warner warn) throws InferenceException { List targs; try { return instantiateExpr(that, to, warn); @@ -388,16 +429,16 @@ private void checkWithinBounds(List tvars, List arguments, Warner warn) - throws NoInstanceException { + throws InvalidInstanceException { for (List tvs = tvars, args = arguments; tvs.nonEmpty(); tvs = tvs.tail, args = args.tail) { if (args.head instanceof UndetVar) continue; List bounds = types.subst(types.getBounds((TypeVar)tvs.head), tvars, arguments); if (!types.isSubtypeUnchecked(args.head, bounds, warn)) - throw unambiguousNoInstanceException + throw invalidInstanceException .setMessage("inferred.do.not.conform.to.bounds", - arguments, tvars); + args.head, bounds); } } } diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java Tue Jun 23 22:09:28 2009 -0700 @@ -299,7 +299,7 @@ boolean allowBoxing, boolean useVarargs, Warner warn) - throws Infer.NoInstanceException { + throws Infer.InferenceException { if (useVarargs && (m.flags() & VARARGS) == 0) return null; Type mt = types.memberType(site, m); @@ -370,7 +370,7 @@ try { return rawInstantiate(env, site, m, argtypes, typeargtypes, allowBoxing, useVarargs, warn); - } catch (Infer.NoInstanceException ex) { + } catch (Infer.InferenceException ex) { return null; } } @@ -584,7 +584,7 @@ default: return bestSoFar; } } - } catch (Infer.NoInstanceException ex) { + } catch (Infer.InferenceException ex) { switch (bestSoFar.kind) { case ABSENT_MTH: return wrongMethod.setWrongSym(sym, ex.getDiagnostic()); diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Tue Jun 23 22:09:28 2009 -0700 @@ -1521,9 +1521,9 @@ int acount = 0; boolean sigReq = - typarams.length() != 0 || supertype.getTypeArguments().length() != 0; + typarams.length() != 0 || supertype.allparams().length() != 0; for (List l = interfaces; !sigReq && l.nonEmpty(); l = l.tail) - sigReq = l.head.getTypeArguments().length() != 0; + sigReq = l.head.allparams().length() != 0; if (sigReq) { assert source.allowGenerics(); int alenIdx = writeAttr(names.Signature); diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties --- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue Jun 23 22:09:28 2009 -0700 @@ -84,7 +84,7 @@ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3} - compiler.err.cant.apply.symbol.1=\ +compiler.err.cant.apply.symbol.1=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ @@ -469,6 +469,8 @@ type parameters of {0} cannot be determined compiler.err.undetermined.type.1=\ type parameters of {0} cannot be determined; {1} +compiler.err.invalid.inferred.types=\ + invalid inferred types for {0}; {1} compiler.err.unreachable.stmt=\ unreachable statement compiler.err.initializer.must.be.able.to.complete.normally=\ @@ -995,7 +997,13 @@ compiler.misc.arg.length.mismatch=\ cannot instantiate from arguments because actual and formal argument lists differ in length compiler.misc.inferred.do.not.conform.to.bounds=\ - inferred type argument(s) {0} do not conform to bounds of type variable(s) {1} + inferred type does not conform to declared bound(s)\n\ + inferred: {0}\n\ + bound(s): {1} +compiler.misc.inferred.do.not.conform.to.params=\ + actual arguments do not conforms to inferred formal arguments\n\ + required: {0}\n\ + found: {1} ##### diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java --- a/langtools/src/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/util/AbstractDiagnosticFormatter.java Tue Jun 23 22:09:28 2009 -0700 @@ -172,9 +172,6 @@ return formatIterable(d, (Iterable)arg, l); } else if (arg instanceof Type) { - if (!allCaptured.contains(arg)) { - allCaptured = allCaptured.append((Type)arg); - } return printer.visit((Type)arg, l); } else if (arg instanceof Symbol) { @@ -482,5 +479,12 @@ protected String capturedVarId(CapturedType t, Locale locale) { return "" + (allCaptured.indexOf(t) + 1); } + @Override + public String visitCapturedType(CapturedType t, Locale locale) { + if (!allCaptured.contains(t)) { + allCaptured = allCaptured.append(t); + } + return super.visitCapturedType(t, locale); + } }; } diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javap/AttributeWriter.java --- a/langtools/src/share/classes/com/sun/tools/javap/AttributeWriter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/AttributeWriter.java Tue Jun 23 22:09:28 2009 -0700 @@ -74,7 +74,7 @@ public class AttributeWriter extends BasicWriter implements Attribute.Visitor { - static AttributeWriter instance(Context context) { + public static AttributeWriter instance(Context context) { AttributeWriter instance = context.get(AttributeWriter.class); if (instance == null) instance = new AttributeWriter(context); diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java --- a/langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java Tue Jun 23 22:09:28 2009 -0700 @@ -93,17 +93,25 @@ this.lastModified = lastModified; } - ClassFile getClassFile() { + protected ClassFile getClassFile() { return classFile; } - Method getMethod() { + protected void setClassFile(ClassFile cf) { + classFile = cf; + constant_pool = classFile.constant_pool; + } + + protected Method getMethod() { return method; } + protected void setMethod(Method m) { + method = m; + } + public void write(ClassFile cf) { - classFile = cf; - constant_pool = classFile.constant_pool; + setClassFile(cf); if ((options.sysInfo || options.verbose) && !options.compat) { if (uri != null) { @@ -197,13 +205,13 @@ println(); } - void writeFields() { + protected void writeFields() { for (Field f: classFile.fields) { writeField(f); } } - void writeField(Field f) { + protected void writeField(Field f) { if (!options.checkAccess(f.access_flags)) return; @@ -259,12 +267,12 @@ println(); } - void writeMethods() { + protected void writeMethods() { for (Method m: classFile.methods) writeMethod(m); } - void writeMethod(Method m) { + protected void writeMethod(Method m) { if (!options.checkAccess(m.access_flags)) return; diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javap/ConstantWriter.java --- a/langtools/src/share/classes/com/sun/tools/javap/ConstantWriter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/ConstantWriter.java Tue Jun 23 22:09:28 2009 -0700 @@ -40,7 +40,7 @@ * deletion without notice. */ public class ConstantWriter extends BasicWriter { - static ConstantWriter instance(Context context) { + public static ConstantWriter instance(Context context) { ConstantWriter instance = context.get(ConstantWriter.class); if (instance == null) instance = new ConstantWriter(context); @@ -54,7 +54,12 @@ options = Options.instance(context); } - void writeConstantPool() { + protected void writeConstantPool() { + ConstantPool constant_pool = classWriter.getClassFile().constant_pool; + writeConstantPool(constant_pool); + } + + protected void writeConstantPool(ConstantPool constant_pool) { ConstantPool.Visitor v = new ConstantPool.Visitor() { public Integer visitClass(CONSTANT_Class_info info, Void p) { println("#" + info.name_index + ";\t// " + stringValue(info)); @@ -114,7 +119,6 @@ }; println(" Constant pool:"); - ConstantPool constant_pool = classWriter.getClassFile().constant_pool; int cpx = 1; while (cpx < constant_pool.size()) { try { @@ -127,7 +131,7 @@ } } - void write(int cpx) { + protected void write(int cpx) { ClassFile classFile = classWriter.getClassFile(); if (cpx == 0) { print("#0"); diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javap/JavapTask.java --- a/langtools/src/share/classes/com/sun/tools/javap/JavapTask.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/JavapTask.java Tue Jun 23 22:09:28 2009 -0700 @@ -36,6 +36,7 @@ import java.io.Writer; import java.security.DigestInputStream; import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; import java.text.MessageFormat; import java.util.ArrayList; import java.util.Arrays; @@ -298,21 +299,28 @@ }; - JavapTask() { + public JavapTask() { context = new Context(); context.put(Messages.class, this); options = Options.instance(context); + attributeFactory = new Attribute.Factory(); } - JavapTask(Writer out, + public JavapTask(Writer out, + JavaFileManager fileManager, + DiagnosticListener diagnosticListener) { + this(); + this.log = getPrintWriterForWriter(out); + this.fileManager = fileManager; + this.diagnosticListener = diagnosticListener; + } + + public JavapTask(Writer out, JavaFileManager fileManager, DiagnosticListener diagnosticListener, Iterable options, Iterable classes) { - this(); - this.log = getPrintWriterForWriter(out); - this.fileManager = fileManager; - this.diagnosticListener = diagnosticListener; + this(out, fileManager, diagnosticListener); try { handleOptions(options, false); @@ -553,29 +561,10 @@ continue; } } - Attribute.Factory attributeFactory = new Attribute.Factory(); attributeFactory.setCompat(options.compat); attributeFactory.setJSR277(options.jsr277); - InputStream in = fo.openInputStream(); - SizeInputStream sizeIn = null; - MessageDigest md = null; - if (options.sysInfo || options.verbose) { - md = MessageDigest.getInstance("MD5"); - in = new DigestInputStream(in, md); - in = sizeIn = new SizeInputStream(in); - } - - ClassFile cf = ClassFile.read(in, attributeFactory); - - if (options.sysInfo || options.verbose) { - classWriter.setFile(fo.toUri()); - classWriter.setLastModified(fo.getLastModified()); - classWriter.setDigest("MD5", md.digest()); - classWriter.setFileSize(sizeIn.size()); - } - - classWriter.write(cf); + write(read(fo)); } catch (ConstantPoolException e) { diagnosticListener.report(createDiagnostic("err.bad.constant.pool", className, e.getLocalizedMessage())); @@ -606,6 +595,103 @@ return ok; } + public static class ClassFileInfo { + ClassFileInfo(JavaFileObject fo, ClassFile cf, byte[] digest, int size) { + this.fo = fo; + this.cf = cf; + this.digest = digest; + this.size = size; + } + public final JavaFileObject fo; + public final ClassFile cf; + public final byte[] digest; + public final int size; + } + + public ClassFileInfo read(JavaFileObject fo) throws IOException, ConstantPoolException { + InputStream in = fo.openInputStream(); + try { + SizeInputStream sizeIn = null; + MessageDigest md = null; + if (options.sysInfo || options.verbose) { + try { + md = MessageDigest.getInstance("MD5"); + } catch (NoSuchAlgorithmException ignore) { + } + in = new DigestInputStream(in, md); + in = sizeIn = new SizeInputStream(in); + } + + ClassFile cf = ClassFile.read(in, attributeFactory); + byte[] digest = (md == null) ? null : md.digest(); + int size = (sizeIn == null) ? -1 : sizeIn.size(); + return new ClassFileInfo(fo, cf, digest, size); + } finally { + in.close(); + } + } + + public void write(ClassFileInfo info) { + ClassWriter classWriter = ClassWriter.instance(context); + if (options.sysInfo || options.verbose) { + classWriter.setFile(info.fo.toUri()); + classWriter.setLastModified(info.fo.getLastModified()); + classWriter.setDigest("MD5", info.digest); + classWriter.setFileSize(info.size); + } + + classWriter.write(info.cf); + } + + protected void setClassFile(ClassFile classFile) { + ClassWriter classWriter = ClassWriter.instance(context); + classWriter.setClassFile(classFile); + } + + protected void setMethod(Method enclosingMethod) { + ClassWriter classWriter = ClassWriter.instance(context); + classWriter.setMethod(enclosingMethod); + } + + protected void write(Attribute value) { + AttributeWriter attrWriter = AttributeWriter.instance(context); + ClassWriter classWriter = ClassWriter.instance(context); + ClassFile cf = classWriter.getClassFile(); + attrWriter.write(cf, value, cf.constant_pool); + } + + protected void write(Attributes attrs) { + AttributeWriter attrWriter = AttributeWriter.instance(context); + ClassWriter classWriter = ClassWriter.instance(context); + ClassFile cf = classWriter.getClassFile(); + attrWriter.write(cf, attrs, cf.constant_pool); + } + + protected void write(ConstantPool constant_pool) { + ConstantWriter constantWriter = ConstantWriter.instance(context); + constantWriter.writeConstantPool(constant_pool); + } + + protected void write(ConstantPool constant_pool, int value) { + ConstantWriter constantWriter = ConstantWriter.instance(context); + constantWriter.write(value); + } + + protected void write(ConstantPool.CPInfo value) { + ConstantWriter constantWriter = ConstantWriter.instance(context); + constantWriter.println(value); + } + + protected void write(Field value) { + ClassWriter classWriter = ClassWriter.instance(context); + classWriter.writeField(value); + } + + protected void write(Method value) { + ClassWriter classWriter = ClassWriter.instance(context); + classWriter.writeMethod(value); + } + private JavaFileManager getDefaultFileManager(final DiagnosticListener dl, PrintWriter log) { return JavapFileManager.create(dl, log, options); } @@ -735,7 +821,7 @@ } } - Context context; + protected Context context; JavaFileManager fileManager; PrintWriter log; DiagnosticListener diagnosticListener; @@ -744,6 +830,7 @@ //ResourceBundle bundle; Locale task_locale; Map bundles; + protected Attribute.Factory attributeFactory; private static final String progname = "javap"; diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/src/share/classes/com/sun/tools/javap/SourceWriter.java --- a/langtools/src/share/classes/com/sun/tools/javap/SourceWriter.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/SourceWriter.java Tue Jun 23 22:09:28 2009 -0700 @@ -134,6 +134,9 @@ } private String readSource(ClassFile cf) { + if (fileManager == null) + return null; + Location location; if (fileManager.hasLocation((StandardLocation.SOURCE_PATH))) location = StandardLocation.SOURCE_PATH; diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/6835430/A.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/6835430/A.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,32 @@ +/* + * Copyright 2009 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. + */ + +class A> { + class C { + public T getT() { return null; } + } +} + +class B extends A { + public class D extends A.C {} +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/6835430/T6835430.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/6835430/T6835430.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,38 @@ +/* + * Copyright 2009 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 6835430 + * @summary 6835430: javac does not generate signature attributes for classes extending parameterized inner classes + * @author mcimadamore + * + * @compile A.java + * @compile T6835430.java + */ + +class T6835430 { + void test(B.D d) { + B b = d.getT(); + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/Diagnostics/6799605/T6799605.java --- a/langtools/test/tools/javac/Diagnostics/6799605/T6799605.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/test/tools/javac/Diagnostics/6799605/T6799605.java Tue Jun 23 22:09:28 2009 -0700 @@ -27,6 +27,7 @@ * @summary Basic/Raw formatters should use type/symbol printer instead of toString() * @author mcimadamore * @compile/fail/ref=T6799605.out -XDrawDiagnostics T6799605.java + * @compile/fail/ref=T6799605.out -XDoldDiags -XDrawDiagnostics T6799605.java */ class T6799605 { diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/Diagnostics/6799605/T6799605.out --- a/langtools/test/tools/javac/Diagnostics/6799605/T6799605.out Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/test/tools/javac/Diagnostics/6799605/T6799605.out Tue Jun 23 22:09:28 2009 -0700 @@ -1,4 +1,4 @@ -T6799605.java:39:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605, kindname.class, T6799605 -T6799605.java:40:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605,T6799605, kindname.class, T6799605 -T6799605.java:41:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605,T6799605,T6799605, kindname.class, T6799605 +T6799605.java:40:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605, kindname.class, T6799605 +T6799605.java:41:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605,T6799605, kindname.class, T6799605 +T6799605.java:42:9: compiler.err.cant.resolve.location.args: kindname.method, m, , T6799605,T6799605,T6799605, kindname.class, T6799605 3 errors diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6302954/T6476073.java --- a/langtools/test/tools/javac/generics/inference/6302954/T6476073.java Wed Jul 05 16:55:03 2017 +0200 +++ b/langtools/test/tools/javac/generics/inference/6302954/T6476073.java Tue Jun 23 22:09:28 2009 -0700 @@ -25,6 +25,7 @@ * @test * @bug 6476073 * @summary Capture using super wildcard of type variables doesn't work + * @ignore awaiting for 6650759 (see bug report for a detailed evaluation) * @compile T6476073.java */ diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712a.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,41 @@ +/* + * Copyright 2009 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 6638712 + * @author mcimadamore + * @summary Inference with wildcard types causes selection of inapplicable method + * @compile/fail/ref=T6638712a.out -XDrawDiagnostics T6638712a.java + */ + +import java.util.*; + +class T6638712a { + + Comparator compound(Iterable> it) {} + + public void test(List> x) { + Comparator c3 = compound(x); + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712a.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712a.out Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,2 @@ +T6638712a.java:39:41: compiler.err.invalid.inferred.types: T, (compiler.misc.inferred.do.not.conform.to.params: java.lang.Iterable>, java.util.List>) +1 error diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712b.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712b.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,39 @@ +/* + * Copyright 2009 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 6638712 + * @author mcimadamore + * @summary Inference with wildcard types causes selection of inapplicable method + * @compile/fail/ref=T6638712b.out -XDrawDiagnostics T6638712b.java + */ + +class T6638712b { + + , T> T m(I test) { return null; } + + void test(T6638712b x) { + String i = m(x); + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712b.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,2 @@ +T6638712b.java:37:21: compiler.err.invalid.inferred.types: T, (compiler.misc.inferred.do.not.conform.to.bounds: T6638712b, T6638712b) +1 error diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712c.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712c.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,41 @@ +/* + * Copyright 2009 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 6638712 6707034 + * @author mcimadamore + * @summary Inference with wildcard types causes selection of inapplicable method + * @compile/fail/ref=T6638712c.out -XDrawDiagnostics T6638712c.java + */ + +import java.util.*; + +class T6638712c { + + T sort(T[] a, Comparator c) { return null; } + + void test(Enum[] e, Comparator> comp) { + sort(e, comp); + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712c.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712c.out Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,2 @@ +T6638712c.java:39:9: compiler.err.cant.apply.symbol: kindname.method, sort, T[],java.util.Comparator, java.lang.Enum[],java.util.Comparator>, kindname.class, T6638712c, null +1 error diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712d.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712d.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,41 @@ +/* + * Copyright 2009 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 6638712 6730468 + * @author mcimadamore + * @summary Inference with wildcard types causes selection of inapplicable method + * @compile/fail/ref=T6638712d.out -XDrawDiagnostics T6638712d.java + */ + +import java.util.*; + +public class T6638712d { + + U m(U u, List> list) { return null; } + + void test(List> lls) { + m(1, lls); + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712d.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,2 @@ +T6638712d.java:39:9: compiler.err.cant.apply.symbol: kindname.method, m, U,java.util.List>, int,java.util.List>, kindname.class, T6638712d, null +1 error diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712e.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712e.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,43 @@ +/* + * Copyright 2009 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 6638712 6795689 + * @author mcimadamore + * @summary Inference with wildcard types causes selection of inapplicable method + * @compile/fail/ref=T6638712e.out -XDrawDiagnostics T6638712e.java + */ + +class T6638712e { + + static class Foo { + Foo m(Foo foo) { return null;} + } + + static class Test { + Foo test(Foo foo1, Foo foo2) { + return foo1.m(foo2); + } + } +} diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/6638712/T6638712e.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,2 @@ +T6638712e.java:40:27: compiler.err.invalid.inferred.types: X, (compiler.misc.inferred.do.not.conform.to.params: T6638712e.Foo, T6638712e.Foo) +1 error diff -r 6107cbff3130 -r b75c1c3bfe72 langtools/test/tools/javac/generics/inference/T6835428.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/generics/inference/T6835428.java Tue Jun 23 22:09:28 2009 -0700 @@ -0,0 +1,38 @@ +/* + * Copyright 2009 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 6835428 + * @author mcimadamore + * @summary regression: return-type inference rejects valid code + * @compile T6835428.java + */ + +class T6835428 { + interface X {} + > T6835428> m() { return null; } + > void test() { + T6835428> t = m(); + } +}