Fix isAsSpecific

isAsSpecific is now dependent on whether we are looking for
a method to apply or a value that does not get applied. Only in
the first case, we should consider apply members of an alternative.

Author: odersky

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

@@ -1252,8 +1252,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  If that tournament yields a draw, a tiebreak is applied where
    *  an alternative that takes more implicit parameters wins over one
    *  that takes fewer.
+   *
+   *  @param  followApply   if true consider `apply` members when comparing with a method reference
    */
-  def compare(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Int = track("compare") { trace(i"compare($alt1, $alt2)", overload) {
+  def compare(alt1: TermRef, alt2: TermRef, followApply: Boolean)(implicit ctx: Context): Int = track("compare") { trace(i"compare($alt1, $alt2)", overload) {
 
     assert(alt1 ne alt2)
 
@@ -1277,8 +1279,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         val formals1 =
           if (tp1.isVarArgsMethod && tp2.isVarArgsMethod) tp1.paramInfos.map(_.repeatedToSingle)
           else tp1.paramInfos
-        isApplicableMethodRef(alt2, formals1, WildcardType) ||
-        tp1.paramInfos.isEmpty && tp2.isInstanceOf[LambdaType]
+        val isAsSpecificMethod =
+          if (followApply) isApplicableType(alt2, formals1, WildcardType)
+          else isApplicableMethodRef(alt2, formals1, WildcardType)
+        isAsSpecificMethod || tp1.paramInfos.isEmpty && tp2.isInstanceOf[LambdaType]
       case tp1: PolyType => // (2)
         val nestedCtx = ctx.fresh.setExploreTyperState()
 
@@ -1424,20 +1428,20 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     else compareWithTypes(fullType1, fullType2) // continue by comparing implicits parameters
   }}
 
-  def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") {
+  def narrowMostSpecific(alts: List[TermRef], followApply: Boolean)(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") {
     alts match {
       case Nil => alts
       case _ :: Nil => alts
       case alt1 :: alt2 :: Nil =>
-        compare(alt1, alt2) match {
+        compare(alt1, alt2, followApply) match {
           case  1 => alt1 :: Nil
           case -1 => alt2 :: Nil
           case  0 => alts
         }
       case alt :: alts1 =>
         def survivors(previous: List[TermRef], alts: List[TermRef]): List[TermRef] = alts match {
           case alt :: alts1 =>
-            compare(previous.head, alt) match {
+            compare(previous.head, alt, followApply) match {
               case  1 => survivors(previous, alts1)
               case -1 => survivors(alt :: previous.tail, alts1)
               case  0 => survivors(alt :: previous, alts1)
@@ -1447,7 +1451,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         val best :: rest = survivors(alt :: Nil, alts1)
         def asGood(alts: List[TermRef]): List[TermRef] = alts match {
           case alt :: alts1 =>
-            if (compare(alt, best) < 0) asGood(alts1) else alt :: asGood(alts1)
+            if (compare(alt, best, followApply) < 0) asGood(alts1) else alt :: asGood(alts1)
           case nil =>
             Nil
         }
@@ -1548,9 +1552,13 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def narrowByTypes(alts: List[TermRef], argTypes: List[Type], resultType: Type): List[TermRef] =
       alts filter (isApplicableType(_, argTypes, resultType))
 
+    val numArgs = pt match {
+      case pt @ FunProto(args, resultType) => args.length
+      case _ => 0
+    }
+
     val candidates = pt match {
       case pt @ FunProto(args, resultType) =>
-        val numArgs = args.length
         val normArgs = args.mapConserve {
           case Block(Nil, expr) => expr
           case x => x
@@ -1658,7 +1666,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       candidates.flatMap(cloneCandidate)
     }
 
-    val found = narrowMostSpecific(candidates)
+    val found = narrowMostSpecific(candidates, followApply = numArgs != 0)
     if (found.length <= 1) found
     else pt match {
       case pt @ FunProto(_, resType: FunProto) =>

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

@@ -1142,7 +1142,7 @@ trait Implicits { self: Typer =>
       def compareCandidate(prev: SearchSuccess, ref: TermRef, level: Int): Int =
         if (prev.ref eq ref) 0
         else if (prev.level != level) prev.level - level
-        else nestedContext().test(implicit ctx => compare(prev.ref, ref))
+        else nestedContext().test(implicit ctx => compare(prev.ref, ref, followApply = false))
 
       /** If `alt1` is also a search success, try to disambiguate as follows:
        *    - If alt2 is preferred over alt1, pick alt2, otherwise return an

tests/neg/i6450.scala

@@ -0,0 +1,9 @@
+trait A {
+  def apply(x: Any): Int =  1
+}
+
+object B {
+  def f(x: Any): Int = 2
+  lazy val f = new A {}
+  val x = f(null)  // error: ambiguous
+}

tests/pos/i6450.scala

@@ -24,3 +24,15 @@ object Test {
   val y1: Int = y
   val z1: Int = z
 }
+
+object Test2 {
+
+  trait A {
+    def apply(x: Any): Int =  1
+  }
+
+  object B {
+    def f(x: Any): A = new A {}
+    lazy val f: A = f(null)
+  }
+}