Consider apply members in constrainResult

So, now we were mis-approximating in the other direction by letting
non-methodic alternatives always pass through the resultConforms
check. This would let members with apply methods pass where they should not.
The problem was previously hidden since members with apply
methods tended to be already filtered out in the isApplicable check.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1470,17 +1470,21 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** Is `alt` a method or polytype whose result type after the first value parameter
      *  section conforms to the expected type `resultType`? If `resultType`
      *  is a `IgnoredProto`, pick the underlying type instead.
+     *  If `alt`does not have method or poly type, and `followApply` is true, consider
+     *  all apply members instead. In all other cases return `true`.
      */
-    def resultConforms(altSym: Symbol, altType: Type, resultType: Type)(implicit ctx: Context): Boolean =
-      resultType.revealIgnored match {
+    def resultConforms(altSym: Symbol, altType: Type, resultType: Type)(implicit ctx: Context): Boolean = {
+      def recur(altType: Type, followApply: Boolean): Boolean = resultType.revealIgnored match {
         case resultType: ValueType =>
           altType.widen match {
-            case tp: PolyType => resultConforms(altSym, constrained(tp).resultType, resultType)
+            case tp: PolyType => recur(constrained(tp).resultType, followApply)
             case tp: MethodType => constrainResult(altSym, tp.resultType, resultType)
-            case _ => true
+            case _ => !followApply || onMethod(altType, followApply)(recur(_, followApply = false))
           }
         case _ => true
       }
+      recur(altType, followApply = true)
+    }
 
     /** If the `chosen` alternative has a result type incompatible with the expected result
      *  type `pt`, run overloading resolution again on all alternatives that do match `pt`.

tests/neg/i6450.scala

@@ -13,55 +13,3 @@ object Test {
   val f: Foo123 = f(1)  // error: Not found: type Foo123
 
 }
-
-object Test2 {
-  trait A {
-    def apply(x: AnyRef): Int
-  }
-  object B {
-    def f(e: Any): A = ???
-    val f: A = f(null)
-  }
-}
-
-object Test3 {
-  trait A {
-    def apply(x: String): Int
-  }
-  object B {
-    def f(e: CharSequence): A = ???
-    val f: A = f(null)
-  }
-}
-
-
-object Test4 {
-  trait A {
-    def apply(x: Any): Int
-  }
-  object B {
-    def f(e: Any): A = ???
-    val f: A = f(null)
-  }
-}
-
-object Test5 {
-  trait A {
-    def apply(x: Any): Int
-  }
-  object B {
-    def f(e: AnyRef): A = ???
-    val f: A = f(null)
-  }
-}
-
-
-object Test6 {
-  trait A {
-    def apply(x: CharSequence): Int
-  }
-  object B {
-    def f(e: String): A = ???
-    val f: A = f(null)
-  }
-}

tests/pos/i6450.scala

@@ -25,7 +25,7 @@ object Test {
   val z1: Int = z
 }
 
-object Test2 {
+object Test1 {
 
   trait A {
     def apply(x: Any): Int =  1
@@ -35,4 +35,57 @@ object Test2 {
     def f(x: Any): A = new A {}
     lazy val f: A = f(null)
   }
+}
+
+object Test2 {
+  trait A {
+    def apply(x: AnyRef): Int
+  }
+  object B {
+    def f(e: Any): A = ???
+    val f: A = ???
+    val g: A = f(null)
+  }
+}
+
+object Test3 {
+  trait A {
+    def apply(x: String): Int
+  }
+  object B {
+    def f(e: CharSequence): A = ???
+    val f: A = f(null)
+  }
+}
+
+
+object Test4 {
+  trait A {
+    def apply(x: Any): Int
+  }
+  object B {
+    def f(e: Any): A = ???
+    val f: A = f(null)
+  }
+}
+
+object Test5 {
+  trait A {
+    def apply(x: Any): Int
+  }
+  object B {
+    def f(e: AnyRef): A = ???
+    val f: A = f(null)
+  }
+}
+
+
+object Test6 {
+  trait A {
+    def apply(x: CharSequence): Int
+  }
+  object B {
+    def f(e: String): A = ???
+    val f: A = f(null)
+  }
 }