[cc] Method expects pure parameter type when the declared parameter type captures a class member

[yawen-guan]

Compiler version

3.2.2

Minimized code

case class A() {}
case class B(a: {*} A) {}
case class C(a: {*} A) {
  var b: {a} B = null
  def setB(b: {a} B): Unit = this.b = b
}

val a: {*} A = new A()
val b: {a} B = new B(a)
val c = new C(a)
c.setB(b) // if change this line to `c.b = b` then the code will pass

Output

[error] -- [E007] Type Mismatch Error: ...
[error] 60 |  c.setB(b)
[error]    |         ^
[error]    |         Found:    (b : {a} B)
[error]    |         Required: B
[error]    |
[error]    | longer explanation available when compiling with `-explain`

Expectation

I expect the code to pass.

[odersky]

Minimization:

class A
class B(a: {*} A)
class C(a: {*} A):
  def setB(b: {a} B): Unit = ???


def test(a1: {*} A)(b1: {a1} B) =
  val c = new C(a1)
  c.setB(b1)

If I instrument a bit I see the following types in the call:

recheck apply c.setB(b1), (c.setB : (b: {c.a} B): Unit)

What happened was that the this of C got replaced with c, so the parameter reference {this.a} became c.a, which is not representable as a capture reference. Since the parameter appears in contra-variant position, the capture set was conservatively approximated with {}.

To do better, we need to extend capture-references to paths. This is on the roadmap, but should maybe be prioritized.