Special rule for {this} in capture sets of class members

[odersky]

Consider the lazylists.scala test in pos-custom-args/captures:

class CC
type Cap = {*} CC

trait LazyList[+A]:
  this: ({*} LazyList[A]) =>

  def isEmpty: Boolean
  def head: A
  def tail: {this} LazyList[A]

object LazyNil extends LazyList[Nothing]:
  def isEmpty: Boolean = true
  def head = ???
  def tail = ???

extension [A](xs: {*} LazyList[A])
  def map[B](f: {*} A => B): {xs, f} LazyList[B] =
    class Mapped extends LazyList[B]:
      this: ({xs, f} Mapped) =>

      def isEmpty = false
      def head: B = f(xs.head)
      def tail: {this} LazyList[B] = xs.tail.map(f)  // OK
    new Mapped

Without this PR, the second to last line is an error since the right hand side
has capture set {xs, f} but the required capture set is this.

To fix this, we widen the expected type of the rhs xs.tail.map(f) from {this} to
{this, f, xs}. That is, we add the declared captures of the self type to the expected
type. The soundness argument for doing this is as follows:

Since tail does not have parameters, the only thing it could capture are references that the
receiver this captures as well. So xs and f must come via this. For instance, if
the receiver xs of xs.tail happens to be pure, then xs.tail is pure as well.

On the other hand, in the neg test lazylists1.scala we add the following line to Mapped:

      def concat(other: {f} LazyList[A]): {this} LazyList[A] = ??? : ({xs, f} LazyList[A]) // error

Here, we cannot widen the expected type from {this} to {this, xs, f} since the result of concat
refers to f independently of this, namely through its parameter other. Hence, if ys: {f} LazyList[String]
then

   LazyNil.concat(ys)

still refers to f even though LazyNil is pure. But if we would accept the definition of concat
above, the type of LazyNil.concat(ys) would be LazyList[String], which is unsound.

The implementation in 7ba98d3 widens the expected type of class members if the class member does not
have tracked parameters. We can refine this to say we widen with all references in
the expected type that are not subsumed by one of the parameter types. This is done in d6a2659

[odersky]

One might be tempted to try the following definition of tail in Mapped:

      def tail: {xs, f} LazyList[B] = xs.tail.map(f)  // error: bad override

That would fail the override check sincetail's type in Mapped is then not seen as a subtype of the tail in LazyList[A].

[odersky]

Happy to report that the original version with LazyCons now also compiles under the new rules

[odersky]

Alex found a counter-example, which means we need to restrict the expected type widening to final classes.
See map5 in neg-customargs/captures/lazylists2.scala