Change shadowing mechanism of extension methods for on par implicit class behavior

[soronpo]

@odersky

Extension methods are really normal methods, so this behavior is not surprising. Here is the example reformulated with normal method surface syntax:

import scala.annotation.targetName
trait Foo[+T]

object Ops:
    @targetName("bazInt")
    def baz(foo : Foo[Int]) : Unit = {}

import Ops.*

@targetName("bazDouble")
def baz(foo : Foo[Double]) : Unit = {}

val f = new Foo[Int] {}
val _ = baz(f) //error

You get basically the same error:

-- [E007] Type Mismatch Error: test.scala:14:12 --------------------------------
14 |val _ = baz(f) //error
   |            ^
   |            Found:    (f : Foo[Int])
   |            Required: Foo[Double]
   |
   | longer explanation available when compiling with `-explain`
1 error found

So none of this is unexpected. It’s what extension methods are. Tweaking that behavior would be dubious at best.

@odersky I started writing a SIP to change this, but I encountered an odd inconsistent behavior trying to formulate the examples. This behavior shows that extension methods are shadowing or not depending on the path to the extended class, and is different from regular methods.

scastie

object ExtMethodsImportedFoo:
  object lib:
    class Foo[T]
    extension (foo: Foo[Int]) def baz: Int = 0

  import lib.*
  extension (foo: Foo[Double]) def baz(arg: Int): Int = arg

  val x = Foo[Int].baz //works ?!

object ExtMethodsGlobalFoo:
  class Foo[T]
  object lib:
    extension (foo: Foo[Int]) def baz: Int = 0

  import lib.*
  extension (foo: Foo[Double]) def baz(arg: Int): Int = arg

  val x = Foo[Int].baz //error ?!


object RegularMethodsImportedFoo:
  object lib:
    class Foo[T]
    def baz(foo: Foo[Int]): Int = 0

  import lib.*
  def baz(foo: Foo[Double])(arg: Int): Int = arg

  val x = baz(Foo[Int]) // error, as expected

object RegularMethodsGlobalFoo:
  class Foo[T]
  object lib:
    def baz(foo: Foo[Int]): Int = 0

  import lib.*
  def baz(foo: Foo[Double])(arg: Int): Int = arg

  val x = baz(Foo[Int]) // error, as expected