Don't generate capture set variables for self types of pure classes

The tricky thing here is how to recognize that a class is pure since
that is known only during capture checking and we are at Setup, the
phase before. But we can approximate by treating the `Pure` trait
as definitely pure.

Author: odersky

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

@@ -522,7 +522,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         tree.symbol match
           case cls: ClassSymbol =>
             val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
-            if (selfInfo eq NoType) || cls.is(ModuleClass) && !cls.isStatic then
+            if ((selfInfo eq NoType) || cls.is(ModuleClass) && !cls.isStatic)
+              && !cls.isPureClass
+            then
               // add capture set to self type of nested classes if no self type is given explicitly.
               val newSelfType = CapturingType(cinfo.selfType, CaptureSet.Var(cls))
               val ps1 = inContext(ctx.withOwner(cls)):

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1443,7 +1443,7 @@ class Definitions {
   /** Base classes that are assumed to be pure for the purposes of capture checking.
    *  Every class inheriting from a pure baseclass is pure.
    */
-  @tu lazy val pureBaseClasses = Set(defn.ThrowableClass)
+  @tu lazy val pureBaseClasses = Set(ThrowableClass, PureClass)
 
   /** Non-inheritable lasses that are assumed to be pure for the purposes of capture checking,
    */

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

@@ -0,0 +1,27 @@
+
+trait Stepper[+A]:
+  this: Stepper[A]^ =>
+
+object Stepper:
+  trait EfficientSplit
+
+sealed trait StepperShape[-T, S <: Stepper[_]^] extends Pure
+
+trait IterableOnce[+A] extends Any:
+  this: IterableOnce[A]^ =>
+  def stepper[S <: Stepper[_]^{this}](implicit shape: StepperShape[A, S]): S = ???
+
+sealed abstract class ArraySeq[sealed T] extends IterableOnce[T], Pure:
+  def array: Array[_]
+
+  def sorted[B >: T](implicit ord: Ordering[B]): ArraySeq[T] =
+    val arr = array.asInstanceOf[Array[T]].sorted(ord.asInstanceOf[Ordering[Any]]).asInstanceOf[Array[T]]
+    ArraySeq.make(arr).asInstanceOf[ArraySeq[T]]
+
+object ArraySeq:
+
+  def make[sealed T](x: Array[T]): ArraySeq[T] = ???
+
+  final class ofRef[T <: AnyRef](val array: Array[T]) extends ArraySeq[T], Pure:
+    override def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S & Stepper.EfficientSplit = ???
+