8025290: javac implicit versus explicit lambda compilation error

Reviewed-by: jjg, dlsmith

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

@@ -250,6 +250,14 @@ public class Attr extends JCTree.Visitor {
         Type owntype = found;
         if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {
             if (allowPoly && inferenceContext.free(found)) {
+                if ((ownkind & ~resultInfo.pkind) == 0) {
+                    owntype = resultInfo.check(tree, inferenceContext.asFree(owntype));
+                } else {
+                    log.error(tree.pos(), "unexpected.type",
+                            kindNames(resultInfo.pkind),
+                            kindName(ownkind));
+                    owntype = types.createErrorType(owntype);
+                }
                 inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
                     @Override
                     public void typesInferred(InferenceContext inferenceContext) {
@@ -511,6 +519,15 @@ public class Attr extends JCTree.Visitor {
         protected ResultInfo dup(CheckContext newContext) {
             return new ResultInfo(pkind, pt, newContext);
         }
+
+        @Override
+        public String toString() {
+            if (pt != null) {
+                return pt.toString();
+            } else {
+                return "";
+            }
+        }
     }
 
     class RecoveryInfo extends ResultInfo {

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

@@ -528,7 +528,7 @@ public class Check {
             inferenceContext.addFreeTypeListener(List.of(req), new FreeTypeListener() {
                 @Override
                 public void typesInferred(InferenceContext inferenceContext) {
-                    checkType(pos, found, inferenceContext.asInstType(req), checkContext);
+                    checkType(pos, inferenceContext.asInstType(found), inferenceContext.asInstType(req), checkContext);
                 }
             });
         }

langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java

@@ -1768,9 +1768,11 @@ public class Infer {
                 public Type apply(Type t) {
                     if (t.hasTag(TYPEVAR)) {
                         TypeVar tv = (TypeVar)t;
-                        return tv.isCaptured() ?
+                        if (tv.isCaptured()) {
-                                new CapturedUndetVar((CapturedType)tv, types) :
+                            return new CapturedUndetVar((CapturedType)tv, types);
-                                new UndetVar(tv, types);
+                        } else {
+                            return new UndetVar(tv, types);
+                        }
                     } else {
                         return t.map(this);
                     }

langtools/src/share/classes/com/sun/tools/javac/util/JavacMessages.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it

langtools/test/tools/javac/lambda/T8025290/ExplicitVSImplicitLambdaTest.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8025290
+ * @summary javac implicit versus explicit lambda compilation error
+ * @compile ExplicitVSImplicitLambdaTest.java
+ */
+
+import java.util.function.*;
+
+public class ExplicitVSImplicitLambdaTest {
+    private void test()
+    {
+        /* in the explicit case "e" is inferred to String so we can use a String
+         * only method.
+         */
+        MyComparator.mycomparing1((String e) -> e.concat(""));
+        MyComparator.mycomparing2((String e) -> e.concat(""));
+        MyComparator.mycomparing3((String e) -> e.concat(""));
+        MyComparator.mycomparing4((String e) -> e.concat(""));
+
+        /* in the implicit case "e" is inferred to Object so toString() is OK.
+         */
+        MyComparator.mycomparing1((e) -> e.toString());
+        MyComparator.mycomparing2((e) -> e.toString());
+        MyComparator.mycomparing3((e) -> e.toString());
+        MyComparator.mycomparing4((e) -> e.toString());
+    }
+}
+
+interface MyComparator<T> {
+    public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing1(
+            Function<? super T, ? extends U> keyExtractor) {
+        return null;
+    }
+
+    public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing2(
+            Function<? super T, ? super U> keyExtractor) {
+        return null;
+    }
+
+    public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing3(
+            Function<? extends T, ? extends U> keyExtractor) {
+        return null;
+    }
+
+    public static <T, U extends Comparable<? super U>> MyComparator<T> mycomparing4(
+            Function<? extends T, ? super U> keyExtractor) {
+        return null;
+    }
+}