Enhancement: Take purity of classes into account when capture checking

Two major changes:

 1. During setup, don't generate a capture set variable for a type T if
   one of the base types of `T` is a pure class.

 2. During subtype checking, admit `cs T <: T` if one of the base types
   of `T` is a pure class. The idea is that in this case we know that the
   capture set will always be empty at runtime.

But don't do (2.) if we are checking self types. In this case the capture set cannot be
stripped. Example:

    class A:
      this: A =>
    class B extends A
      this: {c} B =>

In this case we should not assume `{c} B <: B` since we need to flag an error that the self
type of B does not conform to the self type of A.

   are checking self types. In that cas

Author: odersky

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

@@ -166,16 +166,43 @@ extension (tp: Type)
       case CapturingType(_, _) => true
       case _ => false
 
+  /** Is type known to be always pure by its class structure,
+   *  so that adding a capture set to it would not make sense?
+   */
+  def isAlwaysPure(using Context): Boolean = tp.dealias match
+    case tp: (TypeRef | AppliedType) =>
+      val sym = tp.typeSymbol
+      if sym.isClass then sym.isPureClass
+      else tp.superType.isAlwaysPure
+    case CapturingType(parent, refs) =>
+      parent.isAlwaysPure || refs.isAlwaysEmpty
+    case tp: TypeProxy =>
+      tp.superType.isAlwaysPure
+    case tp: AndType =>
+      tp.tp1.isAlwaysPure || tp.tp2.isAlwaysPure
+    case tp: OrType =>
+      tp.tp1.isAlwaysPure && tp.tp2.isAlwaysPure
+    case _ =>
+      false
+
 extension (sym: Symbol)
 
-  /** A class is pure if one of its base types has an explicitly declared self type
-   *  with an empty capture set.
+  /** A class is pure if:
+   *   - one its base types has an explicitly declared self type with an empty capture set
+   *   - or it is a value class
+   *   - or it is Nothing or Null
    */
   def isPureClass(using Context): Boolean = sym match
     case cls: ClassSymbol =>
+      val AnyValClass = defn.AnyValClass
       cls.baseClasses.exists(bc =>
-        val selfType = bc.givenSelfType
-        selfType.exists && selfType.captureSet.isAlwaysEmpty)
+        bc == AnyValClass
+        || {
+          val selfType = bc.givenSelfType
+          selfType.exists && selfType.captureSet.isAlwaysEmpty
+        })
+      || cls == defn.NothingClass
+      || cls == defn.NullClass
     case _ =>
       false
 

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

@@ -120,38 +120,41 @@ extends tpd.TreeTraverser:
         case tp: (TypeRef | AppliedType) =>
           val sym = tp.typeSymbol
           if sym.isClass then
-            tp.typeSymbol == defn.AnyClass
+            sym == defn.AnyClass
               // we assume Any is a shorthand of {*} Any, so if Any is an upper
               // bound, the type is taken to be impure.
           else superTypeIsImpure(tp.superType)
         case tp: (RefinedOrRecType | MatchType) =>
           superTypeIsImpure(tp.underlying)
         case tp: AndType =>
-          superTypeIsImpure(tp.tp1) || canHaveInferredCapture(tp.tp2)
+          superTypeIsImpure(tp.tp1) || needsVariable(tp.tp2)
         case tp: OrType =>
           superTypeIsImpure(tp.tp1) && superTypeIsImpure(tp.tp2)
         case _ =>
           false
     }.showing(i"super type is impure $tp = $result", capt)
 
     /** Should a capture set variable be added on type `tp`? */
-    def canHaveInferredCapture(tp: Type): Boolean = {
+    def needsVariable(tp: Type): Boolean = {
       tp.typeParams.isEmpty && tp.match
         case tp: (TypeRef | AppliedType) =>
           val tp1 = tp.dealias
-          if tp1 ne tp then canHaveInferredCapture(tp1)
+          if tp1 ne tp then needsVariable(tp1)
           else
             val sym = tp1.typeSymbol
-            if sym.isClass then !sym.isValueClass && sym != defn.AnyClass
+            if sym.isClass then
+              !sym.isPureClass && sym != defn.AnyClass
             else superTypeIsImpure(tp1)
         case tp: (RefinedOrRecType | MatchType) =>
-          canHaveInferredCapture(tp.underlying)
+          needsVariable(tp.underlying)
         case tp: AndType =>
-          canHaveInferredCapture(tp.tp1) && canHaveInferredCapture(tp.tp2)
+          needsVariable(tp.tp1) && needsVariable(tp.tp2)
         case tp: OrType =>
-          canHaveInferredCapture(tp.tp1) || canHaveInferredCapture(tp.tp2)
-        case CapturingType(_, refs) =>
-          refs.isConst && !refs.isUniversal
+          needsVariable(tp.tp1) || needsVariable(tp.tp2)
+        case CapturingType(parent, refs) =>
+          needsVariable(parent)
+          && refs.isConst      // if refs is a variable, no need to add another
+          && !refs.isUniversal // if refs is {*}, an added variable would not change anything
         case _ =>
           false
     }.showing(i"can have inferred capture $tp = $result", capt)
@@ -184,7 +187,7 @@ extends tpd.TreeTraverser:
         CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed)
       case tp @ OrType(tp1, tp2 @ CapturingType(parent2, refs2)) =>
         CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
-      case _ if canHaveInferredCapture(tp) =>
+      case _ if needsVariable(tp) =>
         val cs = tp.dealias match
           case CapturingType(_, refs) => CaptureSet.Var(refs.elems)
           case _ => CaptureSet.Var()

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

@@ -149,15 +149,15 @@ class CheckRealizable(using Context) {
    */
   private def boundsRealizability(tp: Type) = {
 
-    val memberProblems = withMode(Mode.CheckBounds) {
+    val memberProblems = withMode(Mode.CheckBoundsOrSelfType) {
       for {
         mbr <- tp.nonClassTypeMembers
         if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
       yield new HasProblemBounds(mbr.name, mbr.info)
     }
 
-    val refinementProblems = withMode(Mode.CheckBounds) {
+    val refinementProblems = withMode(Mode.CheckBoundsOrSelfType) {
       for {
         name <- refinedNames(tp)
         if (name.isTypeName)

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

@@ -70,10 +70,14 @@ object Mode {
   /** We are currently unpickling Scala2 info */
   val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
 
-  /** We are currently checking bounds to be non-empty, so we should not
-   *  do any widening when computing members of refined types.
+  /** Signifies one of two possible situations:
+   *   1. We are currently checking bounds to be non-empty, so we should not
+   *      do any widening when computing members of refined types.
+   *   2. We are currently checking self type conformance, so we should not
+   *      ignore capture sets added to otherwise pure classes (only needed
+   *      for capture checking).
    */
-  val CheckBounds: Mode = newMode(14, "CheckBounds")
+  val CheckBoundsOrSelfType: Mode = newMode(14, "CheckBoundsOrSelfType")
 
   /** Use Scala2 scheme for overloading and implicit resolution */
   val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")

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

@@ -23,7 +23,7 @@ import typer.ProtoTypes.constrained
 import typer.Applications.productSelectorTypes
 import reporting.trace
 import annotation.constructorOnly
-import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam}
+import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam, isAlwaysPure}
 
 /** Provides methods to compare types.
  */
@@ -522,6 +522,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case CapturingType(parent1, refs1) =>
         if tp2.isAny then true
         else if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1)
+          || !ctx.mode.is(Mode.CheckBoundsOrSelfType) && tp1.isAlwaysPure
         then recur(parent1, tp2)
         else thirdTry
       case tp1: AnnotatedType if !tp1.isRefining =>

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

@@ -615,7 +615,7 @@ object TypeOps:
       boundss: List[TypeBounds],
       instantiate: (Type, List[Type]) => Type,
       app: Type)(
-      using Context): List[BoundsViolation] = withMode(Mode.CheckBounds) {
+      using Context): List[BoundsViolation] = withMode(Mode.CheckBoundsOrSelfType) {
     val argTypes = args.tpes
 
     /** Replace all wildcards in `tps` with `<app>#<tparam>` where `<tparam>` is the

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

@@ -765,11 +765,11 @@ object Types {
         val rinfo = tp.refinedInfo
         if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
           val jointInfo =
-            if rinfo.isInstanceOf[TypeAlias] && !ctx.mode.is(Mode.CheckBounds) then
+            if rinfo.isInstanceOf[TypeAlias] && !ctx.mode.is(Mode.CheckBoundsOrSelfType) then
               // In normal situations, the only way to "improve" on rinfo is to return an empty type bounds
               // So, we do not lose anything essential in "widening" to rinfo.
               // We need to compute the precise info only when checking for empty bounds
-              // which is communicated by the CheckBounds mode.
+              // which is communicated by the CheckBoundsOrSelfType mode.
               rinfo
             else if ctx.base.pendingMemberSearches.contains(name) then
               pinfo safe_& rinfo

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

@@ -101,20 +101,22 @@ object RefChecks {
    *               is the intersection of the capture sets of all its parents
    */
   def checkSelfAgainstParents(cls: ClassSymbol, parents: List[Symbol])(using Context): Unit =
-    val cinfo = cls.classInfo
-
-    def checkSelfConforms(other: ClassSymbol, category: String, relation: String) =
-      val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
-      if otherSelf.exists then
-        if !(cinfo.selfType <:< otherSelf) then
-          report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
-            cls.srcPos)
-
-    for psym <- parents do
-      checkSelfConforms(psym.asClass, "illegal inheritance", "parent")
-    for reqd <- cls.asClass.givenSelfType.classSymbols do
-      if reqd != cls then
-        checkSelfConforms(reqd, "missing requirement", "required")
+    withMode(Mode.CheckBoundsOrSelfType) {
+      val cinfo = cls.classInfo
+
+      def checkSelfConforms(other: ClassSymbol, category: String, relation: String) =
+        val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
+        if otherSelf.exists then
+          if !(cinfo.selfType <:< otherSelf) then
+            report.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
+              cls.srcPos)
+
+      for psym <- parents do
+        checkSelfConforms(psym.asClass, "illegal inheritance", "parent")
+      for reqd <- cls.asClass.givenSelfType.classSymbols do
+        if reqd != cls then
+          checkSelfConforms(reqd, "missing requirement", "required")
+    }
   end checkSelfAgainstParents
 
   /** Check that self type of this class conforms to self types of parents

tests/neg-custom-args/captures/try.check

@@ -10,7 +10,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:29:43 ------------------------------------------
 29 |  val b = handle[Exception, () -> Nothing] {  // error
    |                                           ^
-   |                                           Found:    ? (x: {*} CT[Exception]) -> {x} () -> ? Nothing
+   |                                           Found:    ? (x: {*} CT[Exception]) -> {x} () -> Nothing
    |                                           Required: CanThrow[Exception] => () -> Nothing
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
 31 |  } {

tests/run-custom-args/captures/colltest5/Test_2.scala

@@ -76,7 +76,7 @@ object Test {
     val x4 = xs.head
     val y4: Int = x4
     val x5 = xs.to(List)
-    val y5: {x5} List[Int] = x5
+    val y5: List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
     val ys6: {xs6, isEven} View[Int] = xs6
     val ys7: {xs7, isEven} View[Int] = xs7