Refine rule for this widening

We now widen the expected type of the right hand side of a class member as follows:

Add all references of the declared type of this that are not subsumed by a capture set
of a parameter type.

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -49,7 +49,14 @@ sealed abstract class CaptureSet extends Showable:
   /** Is this capture set definitely non-empty? */
   final def isNotEmpty: Boolean = !elems.isEmpty
 
-  /** Cast to variable. @pre: @isConst */
+  /** Cast to Const. @pre: isConst */
+  def asConst: Const = this match
+    case c: Const => c
+    case v: Var =>
+      assert(v.isConst)
+      Const(v.elems)
+
+  /** Cast to variable. @pre: !isConst */
   def asVar: Var =
     assert(!isConst)
     asInstanceOf[Var]

compiler/src/dotty/tools/dotc/typer/CheckCaptures.scala

@@ -325,10 +325,14 @@ class CheckCaptures extends Recheck:
     override def recheckRHS(tree: Tree, pt: Type, sym: Symbol)(using Context): Type =
       val pt1 = pt match
         case CapturingType(core, refs, _)
-        if sym.owner.isClass
-            && refs.elems.contains(sym.owner.thisType)
-            && sym.paramSymss.forall(_.forall(p => p.isType || p.info.captureSet.isAlwaysEmpty)) =>
-          pt.derivedCapturingType(core, refs ++ sym.owner.asClass.givenSelfType.captureSet)
+        if sym.owner.isClass && refs.elems.contains(sym.owner.thisType) =>
+          val paramCaptures =
+            sym.paramSymss.flatten.foldLeft(CaptureSet.empty) { (cs, p) =>
+              val pcs = p.info.captureSet
+              (cs ++ (if pcs.isConst then pcs else CaptureSet.universal)).asConst
+            }
+          val declaredCaptures = sym.owner.asClass.givenSelfType.captureSet
+          pt.derivedCapturingType(core, refs ++ (declaredCaptures -- paramCaptures))
         case _ =>
           pt
       recheck(tree, pt1)

tests/pos-custom-args/captures/lazylists.scala

@@ -21,6 +21,7 @@ extension [A](xs: {*} LazyList[A])
       def isEmpty = false
       def head: B = f(xs.head)
       def tail: {this} LazyList[B] = xs.tail.map(f)  // OK
+      def concat(other: {f} LazyList[A]): {this, f} LazyList[A] = ??? : ({xs, f} LazyList[A]) // OK
     new Mapped
 
 def test(cap1: Cap, cap2: Cap) =