Avoid deep recursion in sizeFits

Only a single `apply` is ever inserted, so `apply` members of
`apply` methods never should count as applicable.

Author: odersky

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

@@ -1564,7 +1564,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case x => x
         }
 
-        def sizeFits(alt: TermRef): Boolean = alt.widen.stripPoly match {
+        def sizeFits(alt: TermRef, followApply: Boolean): Boolean = alt.widen.stripPoly match {
           case tp: MethodType =>
             val ptypes = tp.paramInfos
             val numParams = ptypes.length
@@ -1575,11 +1575,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             else if (numParams > numArgs + 1) hasDefault
             else isVarArgs || hasDefault
           case tp =>
-            numArgs == 0 || onMethod(tp, followApply = true)(sizeFits)
+            numArgs == 0 ||
+            followApply && onMethod(tp, followApply = true)(sizeFits(_, followApply = false))
         }
 
         def narrowBySize(alts: List[TermRef]): List[TermRef] =
-          alts.filter(sizeFits)
+          alts.filter(sizeFits(_, followApply = true))
 
         def narrowByShapes(alts: List[TermRef]): List[TermRef] = {
           if (normArgs exists untpd.isFunctionWithUnknownParamType)

tests/neg/i6450.scala

@@ -6,4 +6,62 @@ object B {
   def f(x: Any): Int = 2
   lazy val f = new A {}
   val x = f(null)  // error: ambiguous
+}
+
+object Test {
+  def f(x: Any) = 10
+  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)
+  }
 }