Opaque type extension method puzzler

[nicolasstucki]

minimized code

X and MyX are both opaque typed defining extension methods in the same way.

object XObject {
  opaque type X = Int

  def anX: X = 5

  given ops: Object {
    def (x: X) + (y: X): X = x + y
  }
}

object MyXObject {
  opaque type MyX = XObject.X

  def anX: MyX = XObject.anX

  given ops: Object {
    def (x: MyX) + (y: MyX): MyX = x + y
  }
}

object Main extends App {
  println(XObject.anX + XObject.anX) // prints 10
  println(MyXObject.anX + MyXObject.anX) // infinite loop
}

The issue is that when we look + in def (x: MyX) + (y: MyX): MyX = x + y we know that x: XObject.X and therfore both XObject.ops.+ and MyXObject.ops.+ are valid extensions for + but MyXObject.ops.+ is chosen becuase it is closer in scope. The hope here wast to use the primitive XObject.ops.+ on x.

Defining the extensions outside MyXObject fixes the issue but then the extension are not automatically available for the opaque type MyXObject.X.

[nicolasstucki]

This came from an issue encountered in #7795 which was minimized to

object Foo {
  opaque type MyArray = Array[Int]

  def anArray: MyArray = Array(1, 2, 3)

  given ops: Object {
    def (arr: MyArray) drop(n: Int): MyArray = arr.drop(n)
  }
}

object Main extends App {
  println(Foo.anArray.drop(1))
}

[nicolasstucki]

This can be worked around with

def (x: MyX) + (y: MyX): MyX = XObject.ops.+(x)(y)

[odersky]

@nicolasstucki What do you suggest should happen here? I agree it might be surprising, but as far as I can see, that's how it is supposed to work, no?

[nicolasstucki]

Maybe this should have a warning.

[odersky]

What would be the condition in which a warning should be issued?

[nicolasstucki]

In general, if the RHS of the method only calls itself we can warn that this is an infinite recursive call.