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

[Swoorup]

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.

[prolativ]

I'm wondering if what you're trying to do here should be possible at all #14659

[Swoorup]

I'm wondering if what you're trying to do here should be possible at all #14659

I don't see why it should not be possible? Although your example (opaque alias of String overriding Int) definitely looks like it should be an error. It would be nice if there was some mechanism to pass transparentness of opaque type in extension/implementation of trait (as trait could also be used as mixins).

But regardless this current issue still persist even if you avoid override of opaque type:

trait Newtype[Src]:
  opaque type Type = Src

transparent trait BigDecimalNewType extends Newtype[BigDecimal]:
  inline def apply(inline dec: BigDecimal): Type = dec.asInstanceOf[Type]

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

type Amount = Amount.Type
object Amount extends BigDecimalNewType {
  // Uncommenting this fixes the issue.
  // opaque type Blahblahblah = BigDecimal
}

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

[prolativ]

Ok, so that's a separate issue though it might have a similar genesis to #14653.
I minimized it even further

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

object Amount extends BigDecimalNewType {
  val x = Amount(0)
  val y = (x + x) + x
}

but here defining an additional unused opaque type doesn't make everything magically compile

[Swoorup]

but here defining an additional unused opaque type doesn't make everything magically compile

Yeah weird. Adding override opaque type Type = BigDecimal in the Amount companion object does though. Might be yet another issue. 😄

[prolativ]

That particular problem has just been fixed #14665

[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))
}