type "leakage" with transparent methods on opaque types

[erikerlandson]

Compiler version

3.4.2-RC1

Minimized code

opaque type Repro = Int
object Repro:
    extension(v: Int)
        // lift raw Int
        inline def asRepro: Repro = v
    extension(r: Repro)
        // this doesn't need to be transparent but my actual
        // use case does
        transparent inline def *(rr: Repro): Repro =
            r * rr

object repro:
    import Repro.asRepro
    val x = 2.asRepro
    // this "leaks" the type 'Int'
    val y: (Repro & Int) = x * x
    // this should fail but doesn't
    val z = 1 + y

Output

The * method returns type Repro & Int, due to transparent keyword. In other words, it leaks the implementation type Int

Expectation

I need a way for transparent methods to return only Repro, not Repro & Int, to prevent leaky abstraction of the opaque type.

[tschuchortdev]

Possible duplicate: #20302

[erikerlandson]

@tschuchortdev agree, that looks like the same problem

[soronpo]

Also see #13461

[erikerlandson]

@soronpo it worries me a little this bug is 3 years old 😂 Is it fixable? If it's not something likely to be fixed in the near term, I will probably decide to deploy some alternative approaches that are less aesthetically pleasing but maintain proper typing

[soronpo]

I don't know the likeliness of it being fixed. I do wish we had more emphasis on stability in Scala 3.

[erikerlandson]

I just tried removing transparent on my methods, and the dependent types seem to be resolving fine without it. It looks like scala 3 is an improvement here over scala 2.

Since this is working for me, I'll close this issue, although it still seems like a typing problem if you really did need transparent