Drop all IgnoredProto parts before implicit search

Drop all IgnoredProto parts of the expected type before
inferring the arguments of an implicit method. That way,
we propagate all available info by `constrainResult`
into the current constraint before doing the implicit
search. This prevents ambiguity errors. See pos/i5773.scala.

Author: odersky

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -104,6 +104,6 @@ object Mode {
   /** Read comments from definitions when unpickling from TASTY */
   val ReadComments: Mode = newMode(22, "ReadComments")
 
-  /** Suppress insertion of apply or implicit conversion on qualifier */
-  val FixedQualifier: Mode = newMode(23, "FixedQualifier")
+  /** We are synthesizing the receiver of an extension method */
+  val SynthesizeExtMethodReceiver: Mode = newMode(23, "SynthesizeExtMethodReceiver")
 }

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

@@ -799,7 +799,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
        *  part. Return an optional value to indicate success.
        */
       def tryWithImplicitOnQualifier(fun1: Tree, proto: FunProto)(implicit ctx: Context): Option[Tree] =
-        if (ctx.mode.is(Mode.FixedQualifier)) None
+        if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
+          // Suppress insertion of apply or implicit conversion on extension method receiver
+          None
         else
           tryInsertImplicitOnQualifier(fun1, proto, ctx.typerState.ownedVars) flatMap { fun2 =>
             tryEither {
@@ -1691,7 +1693,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     }
     val app =
       typed(untpd.Apply(core, untpd.TypedSplice(receiver) :: Nil), pt1, ctx.typerState.ownedVars)(
-        ctx.addMode(Mode.FixedQualifier))
+        ctx.addMode(Mode.SynthesizeExtMethodReceiver))
     if (!app.symbol.is(Extension))
       ctx.error(em"not an extension method: $methodRef", receiver.sourcePos)
     app

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

@@ -2211,7 +2211,9 @@ class Typer extends Namer
     def tryImplicit(fallBack: => Tree) =
       tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked).getOrElse(fallBack)
 
-    if (ctx.mode.is(Mode.FixedQualifier)) tree
+    if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
+      // Suppress insertion of apply or implicit conversion on extension method receiver
+      tree
     else pt match {
       case pt @ FunProto(Nil, _)
       if tree.symbol.allOverriddenSymbols.exists(_.info.isNullaryMethod) &&
@@ -2395,6 +2397,13 @@ class Typer extends Namer
       }
     }
 
+    /** Reveal ignored parts of prototype when synthesizing the receiver
+     *  of an extension method. This is necessary for pos/i5773.scala
+     */
+    def revealProtoOfExtMethod(tp: Type)(implicit ctx: Context): Type =
+      if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver)) tp.deepenProto
+      else tp
+
     def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {
       assert(wtp.isImplicitMethod)
       val tvarsToInstantiate = tvarsInParams(tree, locked).distinct
@@ -2606,7 +2615,8 @@ class Typer extends Namer
     def adaptNoArgs(wtp: Type): Tree = {
       val ptNorm = underlyingApplied(pt)
       def functionExpected = defn.isFunctionType(ptNorm)
-      def resultMatch = constrainResult(tree.symbol, wtp, followAlias(pt))
+      def resultMatch =
+        constrainResult(tree.symbol, wtp, revealProtoOfExtMethod(followAlias(pt)))
       def needsEta = pt match {
         case _: SingletonType => false
         case IgnoredProto(_: FunOrPolyProto) => false

tests/neg/i5773.scala

@@ -1,5 +1,6 @@
 trait Semigroup[T] {
   def (lhs: T) append (rhs: T): T
+  def (lhs: Int) appendS (rhs: T): T = ???
 }
 
 object Semigroup {
@@ -8,25 +9,24 @@ object Semigroup {
   }
 
   implicit def sumSemigroup[N](implicit N: Numeric[N]): Semigroup[N] = new {
-    override def (lhs: N) append (rhs: N): N = ??? // N.plus(lhs, rhs)
-  }
-
-  implicit class SumSemigroupDeco[N](implicit N: Numeric[N]) extends Semigroup[N] {
-    override def (lhs: N) append (rhs: N): N = ??? // N.plus(lhs, rhs)
+    override def (lhs: N) append (rhs: N): N = N.plus(lhs, rhs)
+    def (lhs: Int) appendS (rhs: N): N = ??? // N.plus(lhs, rhs)
   }
 }
 
 
 object Main {
   import Semigroup.sumSemigroup // this is not sufficient
   def f1 = {
-    import Semigroup.stringAppend // necessary to make the extension method visible
-    println("Hi" append " mum") // ok
-    println(1 append 2) // error: this won't compile
-  }
-
-  def f2 = {
-    implicit val intSumAppend: Semigroup[Int] = sumSemigroup[Int]
-    println(3 append 4) // this will
+    println(1 appendS 2) // error This should give the following error message:
+/*
+21 |    println(1 appendS 2) // error This should give the following error message:
+   |            ^^^^^^^^^
+   |value appendS is not a member of Int.
+   |An extension method was tried, but could not be fully constructed:
+   |
+   |    Semigroup.sumSemigroup[Any](/* ambiguous */implicitly[Numeric[Any]]).appendS()
+one error found
+*/
   }
 }

tests/pos/i5773.scala

@@ -0,0 +1,33 @@
+trait Semigroup[T] {
+  def (lhs: T) append (rhs: T): T
+}
+
+object Semigroup {
+  implicit object stringAppend extends Semigroup[String] {
+    override def (lhs: String) append (rhs: String): String = lhs + rhs
+  }
+
+  implicit def sumSemigroup[N](implicit N: Numeric[N]): Semigroup[N] = new {
+    override def (lhs: N) append (rhs: N): N = ??? // N.plus(lhs, rhs)
+  }
+
+  implicit class SumSemigroupDeco[N](implicit N: Numeric[N]) extends Semigroup[N] {
+    override def (lhs: N) append (rhs: N): N = ??? // N.plus(lhs, rhs)
+  }
+}
+
+
+object Main {
+  import Semigroup.sumSemigroup // this is not sufficient
+  def f1 = {
+    import Semigroup.stringAppend // necessary to make the extension method visible
+    println("Hi" append " mum") // ok
+    //sumSemigroup.apply(1)(2)
+    println(1 append 2) // error: this won't compile
+  }
+
+  def f2 = {
+    implicit val intSumAppend: Semigroup[Int] = sumSemigroup[Int]
+    println(3 append 4) // this will
+  }
+}