Extension methods on different type with same name clash, when using default arguments

[crater2150]

Compiler version

3.1.2

Minimized code

extension (i: Int)
  def foo(x:String = "") = ???
extension (d: Double)
  def foo(x:String = "") = ???

Output

% scalac -3.1.2 -Xprint:typer Main.scala
-- Error: Main.scala:4:6 -------------------------------------------------------
4 |  def foo(x:String = "") = ???
  |      ^
  |      two or more overloaded variants of method foo have default arguments
[[syntax trees at end of                     typer]] // Main.scala
package <empty> {
  final lazy module val Main$package: Main$package = new Main$package()
  final module class Main$package() extends Object() { 
    this: Main$package.type =>
    extension (i: Int) def foo(x: String): Nothing = ???
    def foo$default$2(i: Int): String = ""
    extension (d: Double) def foo(x: String): Nothing = ???
    def foo$default$2(d: Double): String = ""
  }
}

1 error found

Expectation

This should compile, as the methods aren't on the same type, so they should not be ambiguous. Similar to #12245, also @targetName has no effect on the error

[pikinier20]

On the one hand, the ambiguity of these two methods comes from the way the compiler represents extension methods:

extension (i: Int)
  def foo(x:String = "")

is under the hood

def foo(i: Int)(x: String)

On the other hand, the not working targetName annotation might be a bug.

@smarter Could you shed some light on this?

[nicolasstucki]

The best solution for this is to wait until we improve how we handle default arguments. We plan to inline them, which would imply we would not need the foo$default$2 at runtime. We still have some hurdles to overcome to get there.

[smarter]

@targetName doesn't change the fact that methods are overloaded from the perspective of the Scala typechecker so it won't help here.

[pikinier20]

So basically, this limitation isn't a bug and comes from the compiler design and its representation of extension methods and default arguments. The @targetName annotation doesn't affect a typechecker where the error is thrown.