Handle alternatives with same signature in overloading resolution

Turn an assertion into an checked error with an error message
pointing to the root of the problem.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1308,13 +1308,13 @@ object messages {
 
   }
 
-  class AmbiguousOverload(tree: tpd.Tree, val alternatives: List[SingleDenotation], pt: Type)(
+  class AmbiguousOverload(tree: tpd.Tree, val alternatives: List[SingleDenotation], pt: Type, addendum: String = "")(
     implicit ctx: Context)
   extends ReferenceMsg(AmbiguousOverloadID) {
     private def all = if (alternatives.length == 2) "both" else "all"
     def msg =
-      s"""|Ambiguous overload. The ${err.overloadedAltsStr(alternatives)}
-          |$all match ${err.expectedTypeStr(pt)}""".stripMargin
+      em"""|Ambiguous overload. The ${err.overloadedAltsStr(alternatives)}
+           |$all match ${err.expectedTypeStr(pt)}$addendum""".stripMargin
     def explain =
       em"""|There are ${alternatives.length} methods that could be referenced as the compiler knows too little
            |about the expected type.

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

@@ -1364,7 +1364,6 @@ trait Applications extends Compatibility {
    */
   def compare(alt1: TermRef, alt2: TermRef)(using Context): Int = trace(i"compare($alt1, $alt2)", overload) {
     record("compare")
-    assert(alt1 ne alt2)
 
     /** Is alternative `alt1` with type `tp1` as specific as alternative
      *  `alt2` with type `tp2` ?

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

@@ -2796,8 +2796,9 @@ class Typer extends Namer
 
     def adaptOverloaded(ref: TermRef) = {
       val altDenots = ref.denot.alternatives
-      println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
-      val alts = altDenots.map(TermRef(ref.prefix, ref.name, _))
+      typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
+      def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
+      val alts = altDenots.map(altRef)
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
           readaptSimplified(tree.withType(alt))
@@ -2823,11 +2824,20 @@ class Typer extends Namer
                     noMatches
               }
           }
-        case alts =>
+        case ambiAlts =>
           if (tree.tpe.isErroneous || pt.isErroneous) tree.withType(UnspecifiedErrorType)
           else {
-            val remainingDenots = alts map (_.denot.asInstanceOf[SingleDenotation])
-            errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt))
+            val remainingDenots = altDenots.filter(denot => ambiAlts.contains(altRef(denot)))
+            val addendum =
+              if ambiAlts.toSet.size != ambiAlts.size then
+                // Several variants have the same signature. This can happen for structural
+                // type selections. See i8736.scala
+                """|
+                   |
+                   |Note: this happens because one or more alternatives have the same erasure,
+                   |      so they cannot be distinguished by overloading resolution""".stripMargin
+              else ""
+            errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt, addendum))
           }
       }
     }

tests/neg/i8736.check

@@ -0,0 +1,23 @@
+-- [E007] Type Mismatch Error: tests/neg/i8736.scala:29:29 -------------------------------------------------------------
+29 |  def res1: String  = rec.get("k") // error: type mismatch
+   |                      ^^^^^^^^^^^^
+   |                      Found:    Any
+   |                      Required: String
+-- [E007] Type Mismatch Error: tests/neg/i8736.scala:30:29 -------------------------------------------------------------
+30 |  def res2: Int     = rec.get("v") // error: type mismatch
+   |                      ^^^^^^^^^^^^
+   |                      Found:    Any
+   |                      Required: Int
+-- [E051] Reference Error: tests/neg/i8736.scala:31:26 -----------------------------------------------------------------
+31 |  def res3: Boolean = rec.get("z") // error: ambiguous
+   |                      ^^^^^^^
+   |                Ambiguous overload. The overloaded alternatives of method (k: ("k" : String)): String with types
+   |                 (k: ("k" : String)): String
+   |                 (k: ("v" : String)): Int
+   |                 (k: ("z" : String)): Boolean
+   |                all match arguments (("z" : String))
+   |
+   |                Note: this happens because one or more alternatives have the same erasure,
+   |                      so they cannot be distinguised by overloading resolution
+
+longer explanation available when compiling with `-explain`

tests/neg/i8736.scala

@@ -0,0 +1,36 @@
+import reflect.Selectable.reflectiveSelectable
+object App extends App {
+
+  trait Rec0[K <: String] {
+    private[App] val map: Map[String, Any]
+    def get(k: K): Any
+  }
+  def Rec0(map0: Map[String, Any]) = new Rec0[String] {
+    val map = map0
+    def get(k: String): Any = map(k)
+  }
+
+  type Rec[K <: String, V0] = Rec0[K] { def get(k: K): V0 }
+  def field[V](s: String)(v: V): Rec[s.type, V] = Rec0(Map(s -> v)).asInstanceOf[Rec[s.type, V]]
+
+  implicit class RecOps[R <: Rec0[_]](has: R) {
+    def +[K1 <: String, V1](that: Rec[K1, V1]): R with Rec[K1, V1] = Rec0(has.map ++ that.map).asInstanceOf[R with Rec[K1, V1]]
+  }
+
+  def rec:
+    Rec["k", String]
+      with Rec["v", Int]
+      with Rec["z", Boolean]
+    = {
+    field("k")("Str") +
+      field("v")(0) +
+      field("z")(true)
+  }
+  def res1: String  = rec.get("k") // error: type mismatch
+  def res2: Int     = rec.get("v") // error: type mismatch
+  def res3: Boolean = rec.get("z") // error: ambiguous
+
+  //  def res4: Boolean = rec.get("nofield")
+
+  println((res1, res2, res3))
+}