Opaque type weirdness: (self$proxy1 : Any) Required: BigDecimalNewType_this.Type

Opaque types possessing black magic.

It appears that adding 3 or more opaque type numeric causes the code to fail to compile. However here, uncommenting in Line 15 makes the code compile, which is odd, as it is seemingly a random opaque type declaration. Adding 2 Amounts is fine, the issue appears when adding 3 Amounts

Compiler version

3.1.1

Minimized code

trait Newtype[Src]:
  opaque type Type = Src

transparent trait BigDecimalNewType extends Newtype[BigDecimal]:
  override opaque type Type = BigDecimal

  inline def apply(inline dec: BigDecimal): Type = dec

  extension (self: Type)
    inline def value: BigDecimal = self
    inline def +(inline y: Type): Type = self.value + y.value

type Amount = Amount.Type
object Amount extends BigDecimalNewType {
  // opaque type Blahblahblah = BigDecimal
}

case class Fees(
  exchange: Amount,
  slippage: Amount,
  bribe: Amount
):
  def calculateTotalFees: Amount = exchange + slippage + bribe

@main def main(): Unit = 
  val fees: Fees = Fees(Amount(1),Amount(2), Amount(2))
  val totalFees: Amount = fees.calculateTotalFees

  println(s"totalFees: ${totalFees}")

Scastie link: https://scastie.scala-lang.org/MLbciD4bQtysh7mVlYy1ig

Output

Found:    (self$proxy1 : Any)
Required: BigDecimalNewType_this.Type

Expectation

Compile regardless of Line 15 in the code.

[odersky]

Reduced further to:

trait BigDecimalNewType:
  opaque type Type = BigDecimal
  def apply(value: BigDecimal): Type = value
  def value(self: Type): BigDecimal = self
 inline def plus(self: Type, y: Type): Type = apply(value(self) + value(y))

object Amount extends BigDecimalNewType {
  val x = Amount(0)
  val y0 = plus(x, x)
  val y = plus(y0, plus(x, x))
}

Problem goes away if inline is dropped. Problem also exists if inline is replaced with transparent inline. Problem also goes away if BigDecimalNewType is changed to an object, as in:

object BigDecimalNewType:
  opaque type Type = BigDecimal
  def apply(value: BigDecimal): Type = value
  def value(self: Type): BigDecimal = self
  transparent inline def plus(self: Type, y: Type): Type = apply(value(self) + value(y))

object Amount {
  import BigDecimalNewType.*
  val x = BigDecimalNewType(0)
  val y0 = plus(x, x)
  val y = plus(y0, plus(x, x))
}

[prolativ]

I’m wondering if what you’re trying to do here should be possible at all https://github.com/lampepfl/dotty/issues/14659