Mercurial > hg > release > icedtea6-1.8

changeset 2086:d3e0fe2c10b2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
S6638712: Inference with wildcard types causes selection of inapplicable method S6650759: Inference of formal type parameter (unused in formal parameters) is not performed 2010-09-09 Andrew John Hughes <ahughes@redhat.com> * Makefile.am: Add new patches. * NEWS: Document new patches. * patches/openjdk/6638712-wildcard_types.patch, * patches/openjdk/6650759-missing_inference.patch: Fix failure in javac compilation.
author Andrew John Hughes <ahughes@redhat.com>
date Thu, 30 Sep 2010 16:46:39 +0100
parents 4e8e7394fd77
children eab926d1eb04
files ChangeLog Makefile.am NEWS patches/openjdk/6638712-wildcard_types.patch patches/openjdk/6650759-missing_inference.patch
diffstat 5 files changed, 1580 insertions(+), 1 deletions(-) [+]
line wrap: on
line diff
--- a/ChangeLog	Mon Sep 06 14:48:38 2010 +0100
+++ b/ChangeLog	Thu Sep 30 16:46:39 2010 +0100
@@ -1,3 +1,11 @@
+2010-09-09  Andrew John Hughes  <ahughes@redhat.com>
+
+	* Makefile.am: Add new patches.
+	* NEWS: Document new patches.
+	* patches/openjdk/6638712-wildcard_types.patch,
+	* patches/openjdk/6650759-missing_inference.patch:
+	Fix failure in javac compilation.
+
 2010-09-03  Andrew John Hughes  <ahughes@redhat.com>
 
 	* Makefile.am: Add new patch.
--- a/Makefile.am	Mon Sep 06 14:48:38 2010 +0100
+++ b/Makefile.am	Thu Sep 30 16:46:39 2010 +0100
@@ -332,7 +332,9 @@
 	patches/openjdk/6678385.patch \
 	patches/fonts-gentoo.patch \
 	patches/fonts-rhel.patch \
-	patches/icedtea-too-many-args.patch
+	patches/icedtea-too-many-args.patch \
+	patches/openjdk/6638712-wildcard_types.patch \
+	patches/openjdk/6650759-missing_inference.patch
 
 if WITH_RHINO
 ICEDTEA_PATCHES += \
--- a/NEWS	Mon Sep 06 14:48:38 2010 +0100
+++ b/NEWS	Thu Sep 30 16:46:39 2010 +0100
@@ -6,6 +6,8 @@
   - Provide font configuration for RHEL 6.
   - S6951319: enable solaris builds using Sun Studio 12 update 1 (fixes PR398)
   - S6539464, RH500077: Ensure java.lang.Math functions provide consistent results.
+  - S6638712: Inference with wildcard types causes selection of inapplicable method
+  - S6650759: Inference of formal type parameter (unused in formal parameters) is not performed
 - NetX:
   - Fix browser command in BasicService.showDocument(URL)
   - Run programs that inherit main(String[]) in their main-class
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/6638712-wildcard_types.patch	Thu Sep 30 16:46:39 2010 +0100
@@ -0,0 +1,669 @@
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java	2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java	2010-09-09 19:54:58.054019539 +0100
+@@ -1061,6 +1061,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<Type> actuals, Types types) {
++            return types.subst(qtype, tvars, actuals);
++        }
++
+         public Type map(Mapping f) {
+             return f.apply(qtype);
+         }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Types.java openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Types.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Types.java	2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Types.java	2010-09-09 19:54:58.054019539 +0100
+@@ -331,6 +331,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);
+@@ -2766,6 +2774,14 @@
+     /**
+      * Capture conversion as specified by JLS 3rd Ed.
+      */
++
++    public List<Type> capture(List<Type> ts) {
++        List<Type> 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 -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java	2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java	2010-09-09 19:54:58.054019539 +0100
+@@ -383,6 +383,10 @@
+                                      JCDiagnostic.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 syms.errType;
+             }
+         }
+     }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java	2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java	2010-09-09 20:00:32.891268438 +0100
+@@ -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 static com.sun.tools.javac.code.Flags.*;
+ import static com.sun.tools.javac.code.Kinds.*;
+@@ -50,6 +51,7 @@
+ 
+     Symtab syms;
+     Types types;
++    Resolve rs;
+ 
+     public static Infer instance(Context context) {
+         Infer instance = context.get(inferKey);
+@@ -62,43 +64,51 @@
+         context.put(inferKey, this);
+         syms = Symtab.instance(context);
+         types = Types.instance(context);
++        rs = Resolve.instance(context);
+     }
+ 
+-    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;
+ 
+-        NoInstanceException(boolean isAmbiguous) {
++        InferenceException() {
+             this.diagnostic = null;
+-            this.isAmbiguous = isAmbiguous;
+-        }
+-        NoInstanceException setMessage(String key) {
+-            this.diagnostic = JCDiagnostic.fragment(key);
+-            return this;
+-        }
+-        NoInstanceException setMessage(String key, Object arg1) {
+-            this.diagnostic = JCDiagnostic.fragment(key, arg1);
+-            return this;
+-        }
+-        NoInstanceException setMessage(String key, Object arg1, Object arg2) {
+-            this.diagnostic = JCDiagnostic.fragment(key, arg1, arg2);
+-            return this;
+         }
+-        NoInstanceException setMessage(String key, Object arg1, Object arg2, Object arg3) {
+-            this.diagnostic = JCDiagnostic.fragment(key, arg1, arg2, arg3);
++        InferenceException setMessage(String key, Object... args) {
++            this.diagnostic = JCDiagnostic.fragment(key, args);
+             return this;
+         }
++
+         public JCDiagnostic getDiagnostic() {
+             return diagnostic;
+         }
+     }
++
++    public static class NoInstanceException extends InferenceException {
++        private static final long serialVersionUID = 1;
++
++        boolean isAmbiguous; // exist several incomparable best instances?
++
++        NoInstanceException(boolean isAmbiguous) {
++            super();
++            this.isAmbiguous = isAmbiguous;
++       }
++    }
++
++    public static class InvalidInstanceException extends InferenceException {
++        private static final long serialVersionUID = 2;
++
++        InvalidInstanceException() {
++            super();
++        }
++    }
++
+     private final NoInstanceException ambiguousNoInstanceException =
+         new NoInstanceException(true);
+     private final NoInstanceException unambiguousNoInstanceException =
+         new NoInstanceException(false);
++    private final InvalidInstanceException invalidInstanceException = new InvalidInstanceException();
+ 
+ /***************************************************************************
+  * Auxiliary type values and classes
+@@ -247,7 +257,7 @@
+      */
+     public Type instantiateExpr(ForAll that,
+                                 Type to,
+-                                Warner warn) throws NoInstanceException {
++                                Warner warn) throws InferenceException {
+         List<Type> undetvars = Type.map(that.tvars, fromTypeVarFun);
+         for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail) {
+             UndetVar v = (UndetVar) l.head;
+@@ -273,8 +283,7 @@
+         List<Type> 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
+@@ -282,36 +291,42 @@
+      */
+     public Type instantiateMethod(List<Type> tvars,
+                                   MethodType mt,
+-                                  List<Type> argtypes,
+-                                  boolean allowBoxing,
+-                                  boolean useVarargs,
+-                                  Warner warn) throws NoInstanceException {
++                                  final List<Type> argtypes,
++                                  final boolean allowBoxing,
++                                  final boolean useVarargs,
++                                  final Warner warn) throws InferenceException {
+         //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
+         List<Type> undetvars = Type.map(tvars, fromTypeVarFun);
+         List<Type> formals = mt.argtypes;
+-
++        //need to capture exactly once - otherwise subsequent
++        //applicability checks might fail
++        final List<Type> capturedArgs = types.capture(argtypes);
++        List<Type> actuals = capturedArgs;
++        List<Type> 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");
+@@ -319,20 +334,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;
+             }
+         }
+ 
+@@ -363,16 +379,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<Type> inferredTypes = insttypes.toList();
++            final List<Type> 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<Type> inferred, Types types) throws NoInstanceException {
++                    List<Type> 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;
++        }
++        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;
+         }
+-
+-        // return instantiated version of method type
+-        return types.subst(mt, tvars, insttypes.toList());
+     }
+     //where
+ 
+@@ -384,7 +422,7 @@
+         private Type instantiateArg(ForAll that,
+                                     Type to,
+                                     List<Type> tvars,
+-                                    Warner warn) throws NoInstanceException {
++                                    Warner warn) throws InferenceException {
+             List<Type> targs;
+             try {
+                 return instantiateExpr(that, to, warn);
+@@ -401,16 +439,16 @@
+     private void checkWithinBounds(List<Type> tvars,
+                                    List<Type> arguments,
+                                    Warner warn)
+-        throws NoInstanceException {
++        throws InvalidInstanceException {
+         for (List<Type> tvs = tvars, args = arguments;
+              tvs.nonEmpty();
+              tvs = tvs.tail, args = args.tail) {
+             if (args.head instanceof UndetVar) continue;
+             List<Type> 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 -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java	2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java	2010-09-09 19:54:58.058019555 +0100
+@@ -279,7 +279,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);
+ 
+@@ -350,7 +350,7 @@
+         try {
+             return rawInstantiate(env, site, m, argtypes, typeargtypes,
+                                   allowBoxing, useVarargs, warn);
+-        } catch (Infer.NoInstanceException ex) {
++        } catch (Infer.InferenceException ex) {
+             return null;
+         }
+     }
+@@ -562,7 +562,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 -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties openjdk/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties	2010-06-21 22:16:21.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties	2010-09-09 19:54:58.058019555 +0100
+@@ -454,6 +454,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=\
+@@ -960,7 +962,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 -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java	2010-06-21 22:16:25.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java	2010-09-09 19:54:58.058019555 +0100
+@@ -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 -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java	2010-09-09 19:54:58.062019572 +0100
+@@ -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 {
++
++    <T> Comparator<T> compound(Iterable<? extends Comparator<? super T>> it) {}
++
++    public void test(List<Comparator<?>> x) {
++        Comparator<String> c3 = compound(x);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.out	2010-09-09 19:54:58.062019572 +0100
+@@ -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<? extends java.util.Comparator<? super java.lang.String>>, java.util.List<java.util.Comparator<?>>)
++1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.java	2010-09-09 19:54:58.066019583 +0100
+@@ -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<X> {
++
++    <I extends T6638712b<T>, T> T m(I test) { return null; }
++
++    void test(T6638712b<Integer> x) {
++        String i = m(x);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out	2010-09-09 19:54:58.066019583 +0100
+@@ -0,0 +1,2 @@
++T6638712b.java:37:21: compiler.err.invalid.inferred.types: T, (compiler.misc.inferred.do.not.conform.to.bounds: T6638712b<java.lang.Integer>, T6638712b<java.lang.String>)
++1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712c.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712c.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712c.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712c.java	2010-09-09 19:54:58.066019583 +0100
+@@ -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> T sort(T[] a, Comparator<? super T> c) { return null; }
++
++    void test(Enum[] e, Comparator<Enum<?>> comp) {
++        sort(e, comp);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712c.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712c.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712c.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712c.out	2010-09-09 19:54:58.066019583 +0100
+@@ -0,0 +1,2 @@
++T6638712c.java:39:9: compiler.err.cant.apply.symbol: kindname.method, sort, T[],java.util.Comparator<? super T>, java.lang.Enum[],java.util.Comparator<java.lang.Enum<?>>, kindname.class, T6638712c, null
++1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712d.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712d.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712d.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712d.java	2010-09-09 19:54:58.066019583 +0100
+@@ -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> U m(U u, List<List<U>> list) { return null; }
++
++    void test(List<List<String>> lls) {
++        m(1, lls);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712d.out	2010-09-09 19:54:58.066019583 +0100
+@@ -0,0 +1,2 @@
++T6638712d.java:39:9: compiler.err.cant.apply.symbol: kindname.method, m, U,java.util.List<java.util.List<U>>, int,java.util.List<java.util.List<java.lang.String>>, kindname.class, T6638712d, null
++1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.java	2010-09-09 19:54:58.066019583 +0100
+@@ -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<A, B> {
++        <X> Foo<X, B> m(Foo<? super X, ? extends A> foo) { return null;}
++    }
++
++    static class Test {
++        Foo<Object, String> test(Foo<Boolean, String> foo1, Foo<Boolean, Boolean> foo2) {
++             return foo1.m(foo2);
++        }
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out	2010-09-09 19:54:58.066019583 +0100
+@@ -0,0 +1,2 @@
++T6638712e.java:40:27: compiler.err.invalid.inferred.types: X, (compiler.misc.inferred.do.not.conform.to.params: T6638712e.Foo<? super java.lang.Object,? extends java.lang.Boolean>, T6638712e.Foo<java.lang.Boolean,java.lang.Boolean>)
++1 error
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/6650759-missing_inference.patch	Thu Sep 30 16:46:39 2010 +0100
@@ -0,0 +1,898 @@
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java	2010-09-09 20:03:34.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java	2010-09-09 20:24:56.236744893 +0100
+@@ -1063,7 +1063,7 @@
+ 
+         /**
+          * Replaces this ForAll's typevars with a set of concrete Java types
+-         * and returns the instantiated generic type. Subclasses might override
++         * and returns the instantiated generic type. Subclasses should override
+          * in order to check that the list of types is a valid instantiation
+          * of the ForAll's typevars.
+          *
+@@ -1076,6 +1076,42 @@
+             return types.subst(qtype, tvars, actuals);
+         }
+ 
++        /**
++         * Kind of type-constraint derived during type inference
++         */
++        public enum ConstraintKind {
++            /**
++             * upper bound constraint (a type variable must be instantiated
++             * with a type T, where T is a subtype of all the types specified by
++             * its EXTENDS constraints).
++             */
++            EXTENDS,
++            /**
++             * lower bound constraint (a type variable must be instantiated
++             * with a type T, where T is a supertype of all the types specified by
++             * its SUPER constraints).
++             */
++            SUPER,
++            /**
++             * equality constraint (a type variable must be instantiated to the type
++             * specified by its EQUAL constraint.
++             */
++            EQUAL;
++        }
++
++        /**
++         * Get the type-constraints of a given kind for a given type-variable of
++         * this ForAll type. Subclasses should override in order to return more
++         * accurate sets of constraints.
++         *
++         * @param tv the type-variable for which the constraint is to be retrieved
++         * @param ck the constraint kind to be retrieved
++         * @return the list of types specified by the selected constraint
++         */
++        public List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
++            return List.nil();
++        }
++
+         public Type map(Mapping f) {
+             return f.apply(qtype);
+         }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java	2010-09-09 20:03:34.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java	2010-09-09 20:25:15.752817376 +0100
+@@ -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.Type.ForAll.ConstraintKind;
+ import com.sun.tools.javac.code.Symbol.*;
+ 
+ import static com.sun.tools.javac.code.Flags.*;
+@@ -51,6 +52,7 @@
+ 
+     Symtab syms;
+     Types types;
++    Check chk;
+     Resolve rs;
+ 
+     public static Infer instance(Context context) {
+@@ -65,6 +67,7 @@
+         syms = Symtab.instance(context);
+         types = Types.instance(context);
+         rs = Resolve.instance(context);
++        chk = Check.instance(context);
+     }
+ 
+     public static class InferenceException extends RuntimeException {
+@@ -260,14 +263,19 @@
+                                 Warner warn) throws InferenceException {
+         List<Type> undetvars = Type.map(that.tvars, fromTypeVarFun);
+         for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail) {
+-            UndetVar v = (UndetVar) l.head;
++            UndetVar uv = (UndetVar) l.head;
++            TypeVar tv = (TypeVar)uv.qtype;
+             ListBuffer<Type> hibounds = new ListBuffer<Type>();
+-            for (List<Type> l1 = types.getBounds((TypeVar) v.qtype); l1.nonEmpty(); l1 = l1.tail) {
+-                if (!l1.head.containsSome(that.tvars)) {
+-                    hibounds.append(l1.head);
++            for (Type t : that.getConstraints(tv, ConstraintKind.EXTENDS).prependList(types.getBounds(tv))) {
++                if (!t.containsSome(that.tvars) && t.tag != BOT) {
++                    hibounds.append(t);
+                 }
+             }
+-            v.hibounds = hibounds.toList();
++            List<Type> inst = that.getConstraints(tv, ConstraintKind.EQUAL);
++            if (inst.nonEmpty() && inst.head.tag != BOT) {
++                uv.inst = inst.head;
++            }
++            uv.hibounds = hibounds.toList();
+         }
+         Type qtype1 = types.subst(that.qtype, that.tvars, undetvars);
+         if (!types.isSubtype(qtype1, to)) {
+@@ -283,7 +291,7 @@
+         List<Type> targs = Type.map(undetvars, getInstFun);
+         targs = types.subst(targs, that.tvars, targs);
+         checkWithinBounds(that.tvars, targs, warn);
+-        return that.inst(targs, types);
++        return chk.checkType(warn.pos(), that.inst(targs, types), to);
+     }
+ 
+     /** Instantiate method type `mt' by finding instantiations of
+@@ -359,6 +367,9 @@
+         /** Type variables instantiated to bottom */
+         ListBuffer<Type> restvars = new ListBuffer<Type>();
+ 
++        /** Undet vars instantiated to bottom */
++        final ListBuffer<Type> restundet = new ListBuffer<Type>();
++
+         /** Instantiated types or TypeVars if under-constrained */
+         ListBuffer<Type> insttypes = new ListBuffer<Type>();
+ 
+@@ -369,6 +380,7 @@
+             UndetVar uv = (UndetVar)t;
+             if (uv.inst.tag == BOT) {
+                 restvars.append(uv.qtype);
++                restundet.append(uv);
+                 insttypes.append(uv.qtype);
+                 undettypes.append(uv);
+                 uv.inst = null;
+@@ -389,17 +401,32 @@
+             final MethodType mt2 = new MethodType(mt.argtypes, null, mt.thrown, syms.methodClass);
+             mt2.restype = new ForAll(restvars.toList(), mt.restype) {
+                 @Override
++                public List<Type> getConstraints(TypeVar tv, ConstraintKind ck) {
++                    for (Type t : restundet.toList()) {
++                        UndetVar uv = (UndetVar)t;
++                        if (uv.qtype == tv) {
++                            switch (ck) {
++                                case EXTENDS: return uv.hibounds;
++                                case SUPER: return uv.lobounds;
++                                case EQUAL: return uv.inst != null ? List.of(uv.inst) : List.<Type>nil();
++                            }
++                        }
++                    }
++                    return List.nil();
++                }
++
++                @Override
+                 public Type inst(List<Type> inferred, Types types) throws NoInstanceException {
+                     List<Type> formals = types.subst(mt2.argtypes, tvars, inferred);
+-                   if (!rs.argumentsAcceptable(capturedArgs, formals,
++                    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,
++                    }
++                    // check that inferred bounds conform to their bounds
++                    checkWithinBounds(all_tvars,
+                            types.subst(inferredTypes, tvars, inferred), warn);
+-                   return super.inst(inferred, types);
++                    return super.inst(inferred, types);
+             }};
+             return mt2;
+         }
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java	2010-09-09 20:03:34.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java	2010-09-09 20:24:56.236744893 +0100
+@@ -25,7 +25,6 @@
+  * @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 -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out	2010-09-09 20:03:34.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712b.out	2010-09-09 20:26:25.205075284 +0100
+@@ -1,2 +1,2 @@
+-T6638712b.java:37:21: compiler.err.invalid.inferred.types: T, (compiler.misc.inferred.do.not.conform.to.bounds: T6638712b<java.lang.Integer>, T6638712b<java.lang.String>)
+++T6638712b.java:37:21: compiler.err.prob.found.req: (compiler.misc.incompatible.types.1: (compiler.misc.no.conforming.instance.exists: T, T, java.lang.String)), <T>T, java.lang.String
+ 1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out	2010-09-09 20:03:34.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712e.out	2010-09-09 20:27:14.405257916 +0100
+@@ -1,2 +1,2 @@
+-T6638712e.java:40:27: compiler.err.invalid.inferred.types: X, (compiler.misc.inferred.do.not.conform.to.params: T6638712e.Foo<? super java.lang.Object,? extends java.lang.Boolean>, T6638712e.Foo<java.lang.Boolean,java.lang.Boolean>)
++T6638712e.java:40:27: compiler.err.prob.found.req: (compiler.misc.incompatible.types.1: (compiler.misc.no.conforming.instance.exists: X, T6638712e.Foo<X,java.lang.String>, T6638712e.Foo<java.lang.Object,java.lang.String>)), <X>T6638712e.Foo<X,java.lang.String>, T6638712e.Foo<java.lang.Object,java.lang.String>
+ 1 error
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759a.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759a.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759a.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759a.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,45 @@
++/*
++ * 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     6650759
++ * @author  mcimadamore
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759a.java
++ */
++
++class T6650759a {
++
++    public static interface Interface<T> { }
++    public static class IntegerInterface implements Interface<Integer> { }
++
++    <I extends Interface<T>, T> T getGenericValue(I test) { return null; }
++
++    void testSet(Integer test) { }
++
++    void test() {
++        Integer test = getGenericValue(new IntegerInterface());
++        testSet(getGenericValue(new IntegerInterface()));
++    }
++}
+\ No newline at end of file
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759b.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759b.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759b.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759b.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,52 @@
++/*
++ * 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     6650759
++ * @author  mcimadamore
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759b.java
++ */
++
++public class T6650759b {
++
++    interface A<X extends A<X, Y>, Y extends B<X>> {}
++
++    static class B<X extends A<X, ?>> {}
++
++    interface C<X extends A<X, Y>, Y extends B<X>> {}
++
++    interface D<X extends A<X, Y>, Y extends B<X>> {}
++
++    static class E<X extends A<X, Y>, Y extends B<X>, W extends C<X, Y>> implements D<X, Y> {
++
++        static <X extends A<X, Y>, Y extends B<X>, W extends C<X, Y>> D<X, Y> of(W w) {
++            return null;
++        }
++    }
++
++    <X extends A<X, Y>, Y extends B<X>, W extends C<X, Y>, Z extends D<X, Y>> Z test(W w) {
++        return (Z) E.of(w);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759c.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759c.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759c.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759c.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,49 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759c.java
++ */
++
++import java.util.Collection;
++import java.util.Collections;
++
++public class T6650759c {
++
++  static interface A {}
++
++  static interface B<X extends A> {}
++
++  static interface C<X extends A, Y extends B<X>> {}
++
++  public static <T extends A, U extends B<T>> Collection<C<T,U>> get(U u) {
++    return null;
++  }
++
++  public <T extends A, U extends B<T>> Collection<C<T,U>> test(U u) {
++    return Collections.unmodifiableCollection(get(u));
++  }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759d.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759d.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759d.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759d.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,51 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759d.java
++ */
++
++public class T6650759d {
++
++    static abstract class A<X> {
++
++        static <T> A<T> m(Iterable<? extends T> elements) {
++            return null;
++        }
++    }
++
++    static abstract class B {}
++
++    static abstract class C<X extends B> {}
++
++    <U extends C<V>, V extends B> Iterable<V> get(U u) {
++        return null;
++    }
++
++    <U extends C<V>, V extends B> void m(U u) {
++        A<V> a = A.m(get(u));
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759e.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759e.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759e.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759e.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,52 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759e.java
++ */
++
++import java.util.List;
++
++public class T6650759e {
++
++    static abstract class A<X extends B> {}
++
++    interface B<X extends A> extends D {}
++
++    static abstract class C<X extends D> {}
++
++    interface D {}
++
++    static abstract class E<X extends C<? extends B<?>>> {}
++
++    <U extends C<V>, V extends B<W>, W extends A<V>> W m1(E<U> e) {
++        return m2(e);
++    }
++
++    <U extends C<V>, V extends B<W>, W extends A<V>> W m2(E<U> e) {
++        return null;
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759f.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759f.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759f.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759f.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,50 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759f.java
++ */
++
++import java.util.Collections;
++
++public class T6650759f {
++
++    interface A<X extends A> {}
++
++    static abstract class B<X extends B> implements A<X> {}
++
++    static abstract class C<X extends D> extends B<X> {}
++
++    static class D extends C<D> {}
++
++    <X extends B, Y extends B<X>> Iterable<X> m(Y node) {
++        return null;
++    }
++
++    public void test(D d) {
++        Iterable<D> ops = (true) ? Collections.singletonList(d) : m(d);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759g.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759g.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759g.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759g.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,59 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759g.java
++ */
++
++public class T6650759g {
++
++    static abstract class A<X extends A<X>> {}
++
++    static abstract class B<X extends A<X>> {}
++
++    interface C<X, Y> {}
++
++    static abstract class D<X extends A<X>, Y extends B<X>> implements C<X, Y> {}
++
++    static class E extends A<E> {}
++
++    static class F extends B<E> {}
++
++    static void test(Iterable<E> data) {
++        m3(m2(data, m1(F.class)));
++    }
++
++    static <X extends A<X>, Y extends B<X>> D<X, Y> m1(Class<Y> c) {
++        return null;
++    }
++
++    static <U, V> Iterable<V> m2(Iterable<U> x1, C<? super U, ? extends V> x2) {
++        return null;
++    }
++
++    static void m3(Iterable<F> data) {
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759h.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759h.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759h.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759h.java	2010-09-09 20:24:56.248744934 +0100
+@@ -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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759h.java
++ */
++class T6650759h<X, Y> {
++
++    <A> Object m(A a, T6650759h<?, ? super A> t) {
++        return null;
++    }
++
++    void test(T6650759h<?, Void> t) {
++        m(null, t);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759i.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759i.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759i.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759i.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,54 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759i.java
++ */
++public class T6650759i {
++
++    static class A<X extends A, Y extends B> {}
++
++    static class B<X extends B> {}
++
++    static class C<X extends A<X, Y>, Y extends B<Y>> {}
++
++    static <U extends A<U, V>, V extends B<V>> Class<U> m1(U x) {
++        return null;
++    }
++
++    static <U extends A<U, V>, V extends B<V>> U m2(Class<U> c) {
++        return null;
++    }
++
++    static <W, U extends A<U, V>, V extends B<V>> W m3(Class<W> c1, C<U, V> c2) {
++        return null;
++    }
++
++    static <U extends A<U, V>, V extends B<V>> void test(U u, C<U, V> c) {
++        m2(m1(u));
++        U res = m3(m1(u), c);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759j.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759j.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759j.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759j.java	2010-09-09 20:24:56.248744934 +0100
+@@ -0,0 +1,54 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759j.java
++ */
++
++public class T6650759j {
++
++    static abstract class A<X extends A<X>> {}
++
++    static abstract class B<X extends B<X, Y>, Y> extends A<X> {}
++
++    static abstract class C<X extends C<X, Y>, Y> extends B<X, Y> {}
++
++    interface D {}
++
++    static class E extends C<E, D> {}
++
++    static abstract class F<X extends F<X, Y>, Y extends A<Y>> extends A<X> {}
++
++    static class G extends F<G, E> {}
++
++    static <X extends F<X, Y>, Y extends A<Y>> X m(Iterable<X> it) {
++        return null;
++    }
++
++    static G test(Iterable<G> c) {
++        return m(c);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759k.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759k.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759k.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759k.java	2010-09-09 20:24:56.248744935 +0100
+@@ -0,0 +1,44 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759k.java
++ */
++
++public class T6650759k {
++
++    static class A<X extends A> {}
++
++    static class B<X extends B, Y extends A> {}
++
++    <U extends A<U>, V extends B<V, U>> Object m(Class<V> c) {
++        return null;
++    }
++
++    <U extends A<U>, V extends B<V, U>> void test(Class<V> c) {
++        m(c);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759l.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759l.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759l.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759l.java	2010-09-09 20:24:56.248744935 +0100
+@@ -0,0 +1,46 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile T6650759l.java
++ */
++
++public class T6650759l {
++
++    public static interface A<X> {}
++
++    public static class B implements A<Integer> {}
++
++    public static <X extends A<Y>, Y> Y m1(X x) {
++        return null;
++    }
++
++    public static void m2(Integer i) {}
++
++    public static void test(B b) {
++        m2(m1(b));
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759m.java openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759m.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759m.java	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759m.java	2010-09-09 20:24:56.248744935 +0100
+@@ -0,0 +1,47 @@
++/*
++ * 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     6650759
++ * @summary Inference of formal type parameter (unused in formal parameters) is not performed
++ * @compile/fail/ref=T6650759m.out T6650759m.java -XDrawDiagnostics
++ */
++
++import java.util.*;
++
++class T6650759m {
++    <Z> List<? super Z> m(List<? extends List<? super Z>> ls) {
++        return ls.get(0);
++    }
++
++    void test() {
++        ArrayList<ArrayList<Integer>> lli = new ArrayList<ArrayList<Integer>>();
++        ArrayList<Integer> li = new ArrayList<Integer>();
++        li.add(2);
++        lli.add(li);
++        List<? super String> ls = m(lli); //here
++        ls.add("crash");
++        Integer i = li.get(1);
++    }
++}
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759m.out openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759m.out
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6650759/T6650759m.out	1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6650759/T6650759m.out	2010-09-09 20:24:56.248744935 +0100
+@@ -0,0 +1,2 @@
++T6650759m.java:43:36: compiler.err.prob.found.req: (compiler.misc.incompatible.types), java.util.List<? super java.lang.Integer>, java.util.List<? super java.lang.String>
++1 error