Compiler error caused by import of unrelated extension

[armingensler]

Compiler version

3.0.2

Minimized code

package testcode

class A

class B

object ExtensionA {
  extension (self: A) {
    def id = "A"
  }
}
object ExtensionB {
  extension (self: B) {
    def id = "B"
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    import ExtensionA._
    import ExtensionB._ // without this include the code compiles
    val a = A()
    println(a.id)
  }
}

Output

[error] -- [E008] Not Found Error: E:\Programmieren\scala3_sbt_test2\src\main\scala\testcode\Foo.scala:23:14
[error] 23 |    println(a.id)
[error]    |            ^^^^
[error]    |      value id is not a member of testcode.A.
[error]    |      An extension method was tried, but could not be fully constructed:
[error]    |
[error]    |          testcode.ExtensionB.id(a)    failed with
[error]    |
[error]    |              Found:    (a : testcode.A)
[error]    |              Required: testcode.B

Expectation

It should not ambiguous which extension to use and therefore the ExtensionB import should not matter.

[odersky]

It would be nice if this worked, but it does not work this way. a.id coming from the context is resolved the same as id(a). If you write id(a) instead, you get:

-- [E049] Reference Error: i13558.scala:23:12 ----------------------------------
23 |    println(id(a))
   |            ^^
   |            Reference to id is ambiguous,
   |            it is both imported by import testcode.ExtensionA._
   |            and imported subsequently by import testcode.ExtensionB._

longer explanation available when compiling with `-explain`
-- [E007] Type Mismatch Error: i13558.scala:23:15 ------------------------------
23 |    println(id(a))
   |               ^
   |               Found:    (a : testcode.A)
   |               Required: testcode.B

longer explanation available when compiling with `-explain`
2 errors found

Crucially, two subsequent imports do not created an overloaded reference. They are simply ambiguous. The only thing to do here is to improve the error message so that the ambiguity gets mentioned.

[soronpo]

The problem is that this limitation piles on yet-another-thing-that-implicit-classes-can-do-and-extension-methods-can't.
https://scastie.scala-lang.org/64hBEjr3RdiE0xS50FDtEQ

class A

class B

object ExtensionA {
  implicit class ICA(self: A) {
    def id = "A"
  }
}
object ExtensionB {
  implicit class ICB(self: B) {
    def id = "B"
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    import ExtensionA._
    import ExtensionB._
    val a = A()
    println(a.id)
  }
}

[soronpo]

The workaround for this limitation is to use export:
https://scastie.scala-lang.org/Q0ZU4yYsTXeUPra3RQ7qZQ

class A

class B

object ExtensionA {
  extension (self: A) {
    def id = "A"
  }
}
object ExtensionB {
  extension (self: B) {
    def id = "B"
  }
}
object ExtensionAB{
  export ExtensionA._
  export ExtensionB._
}

object Main {
  def main(args: Array[String]): Unit = {
    import ExtensionAB._
    val a = A()
    println(a.id)
    val b = B()
    println(b.id)
  }
}