Enhancement: Generalize handling of exceptions to all pure base classes

Author: odersky

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

@@ -185,24 +185,27 @@ extension (tp: Type)
     case _ =>
       false
 
+extension (cls: ClassSymbol)
+
+  def pureBaseClass(using Context): Option[Symbol] =
+    cls.baseClasses.find(bc =>
+      defn.pureBaseClasses.contains(bc)
+      || {
+        val selfType = bc.givenSelfType
+        selfType.exists && selfType.captureSet.isAlwaysEmpty
+      })
+
 extension (sym: Symbol)
 
   /** 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
+   *   - or it is an exception
+   *   - or it is one of Nothing, Null, or String
    */
   def isPureClass(using Context): Boolean = sym match
     case cls: ClassSymbol =>
-      val AnyValClass = defn.AnyValClass
-      cls.baseClasses.exists(bc =>
-        bc == AnyValClass
-        || {
-          val selfType = bc.givenSelfType
-          selfType.exists && selfType.captureSet.isAlwaysEmpty
-        })
-      || cls == defn.NothingClass
-      || cls == defn.NullClass
+      cls.pureBaseClass.isDefined || defn.pureSimpleClasses.contains(cls)
     case _ =>
       false
 

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

@@ -326,11 +326,6 @@ object CaptureSet:
   /** Used as a recursion brake */
   @sharable private[dotc] val Pending = Const(SimpleIdentitySet.empty)
 
-  /** The empty capture set with a description that says it's the elf type of an
-   *  exception class.
-   */
-  val emptyOfException: CaptureSet.Const = Const(emptySet, "of an exception class")
-
   def apply(elems: CaptureRef*)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty
     else Const(SimpleIdentitySet(elems.map(_.normalizedRef)*))

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

@@ -516,8 +516,10 @@ class CheckCaptures extends Recheck, SymTransformer:
         for param <- cls.paramGetters do
           if !param.hasAnnotation(defn.ConstructorOnlyAnnot) then
             checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
-        if cls.derivesFrom(defn.ThrowableClass) then
-          checkSubset(thisSet, CaptureSet.emptyOfException, tree.srcPos)
+        for pureBase <- cls.pureBaseClass do
+          checkSubset(thisSet,
+            CaptureSet.empty.withDescription(i"of pure base class $pureBase"),
+            tree.srcPos)
         super.recheckClassDef(tree, impl, cls)
       finally
         curEnv = saved

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

@@ -1349,6 +1349,15 @@ class Definitions {
 
   @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass, SingletonClass)
 
+  /** 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.AnyValClass, defn.ThrowableClass)
+
+  /** Non-inheritable lasses that are assumed to be pure for the purposes of capture checking,
+   */
+  @tu lazy val pureSimpleClasses = Set(StringClass, NothingClass, NullClass)
+
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)

tests/neg-custom-args/captures/capt-depfun.scala

@@ -1,8 +1,9 @@
 import annotation.retains
 class C
 type Cap = C @retains(caps.*)
+class Str
 
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => String @retains(x) => String @retains(x)) = ???
-  val dc: (({y, z} String) => {y, z} String) = ac(g()) // error
+  val ac: ((x: Cap) => Str @retains(x) => Str @retains(x)) = ???
+  val dc: (({y, z} Str) => {y, z} Str) = ac(g()) // error

tests/neg-custom-args/captures/capt-depfun2.scala

@@ -1,11 +1,12 @@
 import annotation.retains
 class C
 type Cap = C @retains(caps.*)
+class Str
 
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => Array[String @retains(x)]) = ???
-  val dc = ac(g()) // error: Needs explicit type Array[? >: String <: {y, z} String]
+  val ac: ((x: Cap) => Array[Str @retains(x)]) = ???
+  val dc = ac(g()) // error: Needs explicit type Array[? >: Str <: {y, z} Str]
                    // This is a shortcoming of rechecking since the originally inferred
-                   // type is `Array[String]` and the actual type after rechecking
-                   // cannot be expressed as `Array[C String]` for any capture set C
+                   // type is `Array[Str]` and the actual type after rechecking
+                   // cannot be expressed as `Array[C Str]` for any capture set C

tests/neg-custom-args/captures/cc-this.check

@@ -9,10 +9,7 @@
 10 |  class C2(val x: () => Int): // error
    |               ^
    |        reference (C2.this.x : () => Int) is not included in allowed capture set {} of the self type of class C2
--- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this.scala:17:8 ---------------------------------------
+-- Error: tests/neg-custom-args/captures/cc-this.scala:17:8 ------------------------------------------------------------
 17 |  class C4(val f: () => Int) extends C3 // error
-   |        ^
-   |        illegal inheritance: self type {C4.this.f} C4 of class C4 does not conform to self type C3
-   |        of parent class C3
-   |
-   | longer explanation available when compiling with `-explain`
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  reference (C4.this.f : () => Int) is not included in allowed capture set {} of pure base class class C3

tests/neg-custom-args/captures/cc-this2.check

@@ -1,8 +1,6 @@
 
--- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 -----------------------------------
+-- Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 --------------------------------------------------------
 2 |class D extends C: // error
-  |      ^
-  |      illegal inheritance: self type {*} D of class D does not conform to self type C
-  |      of parent class C
-  |
-  | longer explanation available when compiling with `-explain`
+  |^
+  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class C
+3 |  this: {*} D =>

tests/neg-custom-args/captures/exception-definitions.check

@@ -1,13 +1,17 @@
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:2:6 -----------------------------------------------
 2 |class Err extends Exception: // error
   |^
-  |reference (scala.caps.* : Any) is not included in allowed capture set {} of an exception class
+  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
 3 |  self: {*} Err =>
+-- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
+10 |class Err4(c: {*} Any) extends AnyVal // error
+   |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |reference (Err4.this.c : {*} Any) is not included in allowed capture set {} of pure base class class AnyVal
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:7:12 ----------------------------------------------
 7 |    val x = c  // error
   |            ^
-  |   (c : {*} Any) cannot be referenced here; it is not included in the allowed capture set {} of an exception class
+  |(c : {*} Any) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:8:8 -----------------------------------------------
 8 |  class Err3(c: {*} Any) extends Exception // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  reference (Err3.this.c : {*} Any) is not included in allowed capture set {} of an exception class
+  |  reference (Err3.this.c : {*} Any) is not included in allowed capture set {} of pure base class class Throwable

tests/neg-custom-args/captures/exception-definitions.scala

@@ -7,4 +7,6 @@ def test(c: {*} Any) =
     val x = c  // error
   class Err3(c: {*} Any) extends Exception // error
 
+class Err4(c: {*} Any) extends AnyVal // error
+
 

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

@@ -9,7 +9,7 @@
 5 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz.this} Foo{m: {Baz.this} String}
+  |  {Baz.this} Foo{m: {*} String}
   |  with non-empty capture set {Baz.this}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:7:6 --------------------------------------------------------------
@@ -23,6 +23,6 @@
 9 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz2.this} Foo{m: {Baz2.this} String}
+  |  {Baz2.this} Foo{m: {*} String}
   |  with non-empty capture set {Baz2.this}.
   |  The type needs to be declared explicitly.

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

@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:23:49 ------------------------------------------
 23 |  val a = handle[Exception, CanThrow[Exception]] { // error
    |                                                 ^
-   |                                                 Found:    ? ({*} CT[Exception]) -> CanThrow[? Exception]
+   |                                                 Found:    ? ({*} CT[Exception]) -> CanThrow[Exception]
    |                                                 Required: CanThrow[Exception] => box {*} CT[Exception]
 24 |    (x: CanThrow[Exception]) => x
 25 |  }{

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

@@ -9,7 +9,7 @@
 15 |  val u = a  // error
    |          ^
    |          Found:    (a : box {*} String -> String)
-   |          Required: {*} (x$0: ? String) -> ? String
+   |          Required: {*} (x$0: String) -> String
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
@@ -25,7 +25,7 @@
 -- Error: tests/neg-custom-args/captures/vars.scala:32:8 ---------------------------------------------------------------
 32 |  local { cap3 => // error
    |  ^
-   |  The expression's type box {*} (x$0: ? String) -> ? String is not allowed to capture the root capability `*`.
+   |  The expression's type box {*} (x$0: String) -> String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 34 |    g