Improve error message for conflicting definitions

Now includes the signature in the message also when emitted from the typer.

Co-authored-by: Matthieu Bovel <[email protected]>

Author: Jannyboy11

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

@@ -38,6 +38,7 @@ import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.config.SourceVersion
 import DidYouMean.*
 import Message.Disambiguation
+import dotty.tools.dotc.transform.Erasure
 
 /**  Messages
   *  ========
@@ -2333,7 +2334,7 @@ class DoubleDefinition(decl: Symbol, previousDecl: Symbol, base: Symbol)(using C
 extends NamingMsg(DoubleDefinitionID) {
   def msg(using Context) = {
     def nameAnd = if (decl.name != previousDecl.name) " name and" else ""
-    def erasedType = if ctx.erasedTypes then i" ${decl.info}" else ""
+    def erasedType = if ctx.erasedTypes then i"${decl.info}" else s"${atPhase(Phases.erasurePhase) {(decl.info.show)}}"
     def details(using Context): String =
       if (decl.isRealMethod && previousDecl.isRealMethod) {
         import Signature.MatchDegree.*
@@ -2361,7 +2362,7 @@ extends NamingMsg(DoubleDefinitionID) {
                     |Consider adding a @targetName annotation to one of the conflicting definitions
                     |for disambiguation."""
               else ""
-            i"have the same$nameAnd type$erasedType after erasure.$hint"
+            i"have the same$nameAnd type $erasedType after erasure.$hint"
         }
       }
       else ""
@@ -2374,7 +2375,7 @@ extends NamingMsg(DoubleDefinitionID) {
     }
     val clashDescription =
       if (decl.owner eq previousDecl.owner)
-        "Double definition"
+        "Conflicting definitions"
       else if ((decl.owner eq base) || (previousDecl eq base))
         "Name clash between defined and inherited member"
       else

tests/neg/i23402.check

@@ -0,0 +1,10 @@
+-- [E120] Naming Error: tests\neg\i23402.scala:4:5 ---------------------------------------------------------------------
+4 | def apply(p1: String)(p2: Int): A = A(p1, p2) // error
+  |     ^
+  |     Conflicting definitions:
+  |     def apply(p1: String, p2: Int): A in object A at line 3 and
+  |     def apply(p1: String)(p2: Int): A in object A at line 4
+  |     have the same type (p1: String)(p2: Int): A after erasure.
+  |
+  |     Consider adding a @targetName annotation to one of the conflicting definitions
+  |     for disambiguation.

tests/neg/i23402.scala

@@ -0,0 +1,5 @@
+class A(p1: String, p2: Int)
+object A {
+ def apply(p1: String, p2: Int): A = A(p1, p2)
+ def apply(p1: String)(p2: Int): A = A(p1, p2) // error
+}

tests/neg/i23402b.check

@@ -0,0 +1,10 @@
+-- [E120] Naming Error: tests\neg\i23402b.scala:4:5 --------------------------------------------------------------------
+4 | def apply[T](p1: String)(p2: Int): A = A(p1, p2) // error
+  |     ^
+  |     Conflicting definitions:
+  |     def apply[T](p1: String, p2: Int): A in object A at line 3 and
+  |     def apply[T](p1: String)(p2: Int): A in object A at line 4
+  |     have the same type [T](p1: String)(p2: Int): A after erasure.
+  |
+  |     Consider adding a @targetName annotation to one of the conflicting definitions
+  |     for disambiguation.

tests/neg/i23402b.scala

@@ -0,0 +1,5 @@
+class A(p1: String, p2: Int)
+object A {
+ def apply[T](p1: String, p2: Int): A = A(p1, p2)
+ def apply[T](p1: String)(p2: Int): A = A(p1, p2) // error
+}

tests/neg/i23402c.check

@@ -0,0 +1,10 @@
+-- [E120] Naming Error: tests\neg\i23402c.scala:4:5 --------------------------------------------------------------------
+4 | def apply[T](p1: String)(p2: Int): A = A(p1, p2) // error
+  |     ^
+  |     Conflicting definitions:
+  |     def apply(p1: String, p2: Int): A in object A at line 3 and
+  |     def apply[T](p1: String)(p2: Int): A in object A at line 4
+  |     have the same type (p1: String, p2: Int): A after erasure.
+  |
+  |     Consider adding a @targetName annotation to one of the conflicting definitions
+  |     for disambiguation.

tests/neg/i23402c.scala

@@ -0,0 +1,5 @@
+class A(p1: String, p2: Int)
+object A {
+ def apply(p1: String, p2: Int): A = A(p1, p2)
+ def apply[T](p1: String)(p2: Int): A = A(p1, p2) // error
+}