Unhelpful type erasure error with multiple parameter groups

[threeseed]

Compiler version

3.7.0

Minimized example

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)
}

Output Error/Warning message

The error message from Scastie:

Double definition:
def apply(p1: String, p2: Int): Playground.A in object A at line 5 and
def apply(p1: String)(p2: Int): Playground.A in object A at line 6
have the same type after erasure.

Consider adding a @targetName annotation to one of the conflicting definitions
for disambiguation.

Why this Error/Warning was not helpful

I don't know what I am supposed to do with this message.

It doesn't explain to me how to fix the code, what the "same type" is or what type erasure means in my specific situation.

Suggested improvement

If multiple parameter groups are being concatenated together in the compiler it would be useful to mention that as the reason why this code is not allowed. Type erasure in general shouldn't be mentioned as it seems like an implementation detail.

[som-snytt]

As a heads up, the Scastie is on 2.12.

Type erasure is not an implementation detail. https://scala-lang.org/files/archive/spec/3.4/03-types.html#type-erasure

Scala 3 reports Double definition, which is unfortunate because Double spells the type. (One may say double trouble.)

"Conflicting definitions", as there are certainly two of them (before erasure, a phase name that puts every student in mind of a number 2 pencil). (Or "under erasure" for those who just found Derrida.) The minimal diff, "Doubled definition", is a tongue-twister.

An extended explanation could be put under -explain.

-- [E120] Naming Error: ...
5 |  def apply(p1: String)(p2: Int): A = A(p1, p2)
  |      ^
  |Double definition:
  |def apply(p1: String, p2: Int): A in object A at line 4 and
  |def apply(p1: String)(p2: Int): A in object A at line 5
  |have the same type after erasure.
  |
  |Consider adding a @targetName annotation to one of the conflicting definitions
  |for disambiguation.

I wonder if Scala 3 reports the erased definition if it differs from both surface language definitions.

Scala 2 again, for reference, showing what the "same type" is:

error: double definition:
def apply(p1: String, p2: Int): A at line 4 and
def apply(p1: String)(p2: Int): A at line 5
have same type after erasure: (p1: String, p2: Int): A
  def apply(p1: String)(p2: Int): A = A(p1, p2)
      ^

[sjrd]

Showing what the same type is after erasure would definitely go a long way to make this error more approachable. 👍

[threeseed]

Updated the original comment to use the Scala 3 error message.

I think it's important to think about error messages as if you were new to Scala.
Type erasure is a foreign concept, the page you listed is incoherent maths and I just want you to tell me what to do.

Just adding the type is useful but not enough.

Related: #23350

[sjrd]

I just want you to tell me what to do.

Isn't that exactly what the current message does?

Consider adding a @targetName annotation to one of the conflicting definitions for disambiguation.

Type erasure is a foreign concept

Not naming the concept in the error message will only make it less searchable.

[threeseed]

@sjrd .. I have provided my feedback that I found the error messages to be unhelpful.

If you're okay with them feel feel to close the two tickets.

[som-snytt]

I'm still like what's a targetName, so I think a big -explain text would be helpful.

(It's possible the two tickets ask for the same supplement?)

I happen to be tweaking something in Scala 2 uncurry, and even when you see the moving parts, it can be confusing. Considering the magic that happens for various language features, it's not unreasonable to expect that "parameter lists" is something the compiler could encode in a way that preserves what I wrote.

In other words, why do I have to come up with a target name? Naming is hard! Scalac, why don't you come up with a name?