Overloaded assignment operators defined as extension methods across different objects fail to compile

[ntnj]

Compiler version

3.4.0-RC1-bin-20231006-b1ccc6a-NIGHTLY

Minimized code

Scastie: https://scastie.scala-lang.org/cYHDxwGgQzm3VBWrIHYQhA

a.scala

import language.experimental.relaxedExtensionImports
class A(var x: String = "a")
object AA:
    extension (a: A)
        def f = a.x
        def f_=(x: String) = a.x = x

b.scala

import language.experimental.relaxedExtensionImports
class B(var x: String = "b")
object BB:
    extension (b: B)
        def f = b.x
        def f_=(x: String) = b.x = x

main.scala

import language.experimental.relaxedExtensionImports
import AA.*
import BB.* 
@main def main() =
    val a = A()
    a.f = "aa"
    println(a.f)

Output

sbt:tmp> run
[info] compiling 1 Scala source to /workspaces/tmp/target/scala-3.4.0-RC1-bin-20231006-b1ccc6a-NIGHTLY/classes ...
[error] -- [E052] Type Error: /workspaces/tmp/main.scala:7:8 --------
[error] 6 |    a.f = "aa"
[error]   |    ^^^^^^^^^^
[error]   |    Reassignment to val f

If I remove def f_=(x: String) = b.x = x from B extension, it runs successfully with run in sbt console.

When I then add it back, it runs successfully with run in sbt console, but fails again on run after clean, which is potentially a partial compilation bug.

Expectation

aa

[nicolasstucki]

Minimization

import language.experimental.relaxedExtensionImports

class A
object AA:
  extension (a: A)
    def f = ???
    def f_=(x: String) = ???

object BB:
  extension (b: Long)
    def f = ???
    def f_=(x: String) = ???

def test(a: A) =
  import AA.*
  import BB.*
  a.f = "aa"
  f_=(a)("aa")

-- [E052] Type Error: t/Test.scala:17:6 ----------------------------------------
17 |  a.f = "aa"
   |  ^^^^^^^^^^
   |  Reassignment to val f
   |
   | longer explanation available when compiling with `-explain`
-- [E049] Reference Error: t/Test.scala:18:2 -----------------------------------
18 |  f_=(a)("bb")
   |  ^^^
   |Reference to f_= is ambiguous.
   |It is both imported by import AA._
   |and imported subsequently by import BB._
   |
   | Hint: This error may arise if extension method `f_=` is called as a normal method.
   |
   | longer explanation available when compiling with `-explain`
-- [E007] Type Mismatch Error: t/Test.scala:18:6 -------------------------------
18 |  f_=(a)("bb")
   |      ^
   |      Found:    (a : A)
   |      Required: Long
   |
   | longer explanation available when compiling with `-explain`

[nicolasstucki]

It looks like the implementation of #9552 defaults to this error message here when the reference is ambiguous.

[nicolasstucki]

When resolving the setter we get first type the prefix to AA.f, but then when we desugar it into the setter we use the Ident f_= which gets typed as BB.f_= instead of AA.f_=. We seem to lose the typed qualifier of the extension method.