Miscellaneous CC fixes and tweaks

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

@@ -25,6 +25,11 @@ object ccConfig:
    */
   inline val allowUnsoundMaps = false
 
+  /** If true, expand capability classes in Setup instead of treating them
+   *  in adapt. 
+   */
+  val expandCapabilityInSetup = true
+
   /** If true, use `sealed` as encapsulation mechanism instead of the
    *  previous global retriction that `cap` can't be boxed or unboxed.
    */

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

@@ -157,15 +157,15 @@ sealed abstract class CaptureSet extends Showable:
           case y: TermRef =>
             (y.prefix eq x)
             || y.info.match
-                case y1: CaptureRef => x.subsumes(y1)
+                case y1: SingletonCaptureRef => x.subsumes(y1)
                 case _ => false
           case MaybeCapability(y1) => x.stripMaybe.subsumes(y1)
           case _ => false
       || x.match
           case ReachCapability(x1) => x1.subsumes(y.stripReach)
           case x: TermRef =>
             x.info match
-              case x1: CaptureRef => x1.subsumes(y)
+              case x1: SingletonCaptureRef => x1.subsumes(y)
               case _ => false
           case _ => false
 
@@ -1058,7 +1058,7 @@ object CaptureSet:
         case tp: TermParamRef =>
           tp.captureSet
         case tp: TypeRef =>
-          if tp.derivesFromCapability then universal // TODO: maybe return another value that indicates that the underltinf ref is maximal?
+          if !ccConfig.expandCapabilityInSetup && tp.derivesFromCapability then universal
           else empty
         case _: TypeParamRef =>
           empty

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

@@ -28,16 +28,13 @@ object CapturingType:
 
   /** Smart constructor that
    *   - drops empty capture sets
-   *   - drops a capability class expansion if it is further refined with another capturing type
    *   - fuses compatible capturing types.
    *  An outer type capturing type A can be fused with an inner capturing type B if their
    *  boxing status is the same or if A is boxed.
    */
   def apply(parent: Type, refs: CaptureSet, boxed: Boolean = false)(using Context): Type =
     if refs.isAlwaysEmpty then parent
     else parent match
-      case parent @ CapturingType(parent1, refs1) if refs1 eq defn.expandedUniversalSet =>
-        apply(parent1, refs, boxed)
       case parent @ CapturingType(parent1, refs1) if boxed || !parent.isBoxed =>
         apply(parent1, refs ++ refs1, boxed)
       case _ =>

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

@@ -1078,7 +1078,9 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** If actual derives from caps.Capability, yet is not a capturing type itself,
      *  make its capture set explicit.
      */
-    private def makeCaptureSetExplicit(actual: Type)(using Context): Type = actual match
+    private def makeCaptureSetExplicit(actual: Type)(using Context): Type =
+      if ccConfig.expandCapabilityInSetup then actual
+      else actual match
       case CapturingType(_, _) => actual
       case _ if actual.derivesFromCapability =>
         val cap: CaptureRef = actual match
@@ -1284,7 +1286,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 case ref: TermParamRef
                 if !allowed.contains(ref) && !seen.contains(ref) =>
                   seen += ref
-                  if ref.underlying.isRef(defn.Caps_Capability) then
+                  if ref.isMaxCapability then
                     report.error(i"escaping local reference $ref", tree.srcPos)
                   else
                     val widened = ref.captureSetOfInfo

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

@@ -306,7 +306,10 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case t: TypeVar =>
             this(t.underlying)
           case t =>
-            recur(t)
+            // Map references to capability classes C to C^
+            if ccConfig.expandCapabilityInSetup && t.derivesFromCapability
+            then CapturingType(t, CaptureSet.universal, boxed = false)
+            else recur(t)
     end expandAliases
 
     val tp1 = expandAliases(tp) // TODO: Do we still need to follow aliases?
@@ -575,10 +578,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         !refs.isEmpty
       case tp: (TypeRef | AppliedType) =>
         val sym = tp.typeSymbol
-        if sym.isClass then
-          !sym.isPureClass
-        else
-          sym != defn.Caps_Capability && instanceCanBeImpure(tp.superType)
+        if sym.isClass then !sym.isPureClass
+        else instanceCanBeImpure(tp.superType)
       case tp: (RefinedOrRecType | MatchType) =>
         instanceCanBeImpure(tp.underlying)
       case tp: AndType =>
@@ -711,8 +712,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
       if ref.captureSetOfInfo.elems.isEmpty then
         report.error(em"$ref cannot be tracked since its capture set is empty", pos)
-      if parent.captureSet ne defn.expandedUniversalSet then
-        check(parent.captureSet, parent)
+      check(parent.captureSet, parent)
 
       val others =
         for j <- 0 until retained.length if j != i yield retained(j).toCaptureRef

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

@@ -998,7 +998,6 @@ class Definitions {
     @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
     @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")
     @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")
-    @tu lazy val expandedUniversalSet: CaptureSet = CaptureSet(captureRoot.termRef)
 
   @tu lazy val PureClass: Symbol = requiredClass("scala.Pure")
 

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

@@ -1646,10 +1646,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else
           val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
           val paramTpts = appDef.termParamss.head.map(p => TypeTree(p.tpt.tpe).withSpan(p.tpt.span))
-          val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
+          val funSym = defn.FunctionSymbol(numArgs, isContextual)
           val tycon = TypeTree(funSym.typeRef)
           AppliedTypeTree(tycon, paramTpts :+ resTpt)
-      RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
+      val res = RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
+      if isImpure then
+        typed(untpd.makeRetaining(untpd.TypedSplice(res), Nil, tpnme.retainsCap), pt)
+      else
+        res
     end typedDependent
 
     args match {

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

@@ -1,8 +1,13 @@
 -- Error: tests/neg-custom-args/captures/byname.scala:19:5 -------------------------------------------------------------
 19 |  h(g()) // error
    |    ^^^
-   |    reference (cap2 : Cap) is not included in the allowed capture set {cap1}
+   |    reference (cap2 : Cap^) is not included in the allowed capture set {cap1}
    |    of an enclosing function literal with expected type () ?->{cap1} I
+-- Error: tests/neg-custom-args/captures/byname.scala:22:12 ------------------------------------------------------------
+22 |  h2(() => g())() // error
+   |           ^^^
+   |           reference (cap2 : Cap^) is not included in the allowed capture set {cap1}
+   |           of an enclosing function literal with expected type () ->{cap1} I
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:4:2 -----------------------------------------
  4 |  def f() = if cap1 == cap1 then g else g // error
    |  ^

tests/neg-custom-args/captures/byname.scala

@@ -17,6 +17,9 @@ def test2(cap1: Cap, cap2: Cap): I^{cap1} =
   def h(x: ->{cap1} I) = x // ok
   h(f()) // OK
   h(g()) // error
+  def h2(x: () ->{cap1} I) = x // ok
+  h2(() => f()) // OK
+  h2(() => g())() // error
 
 
 

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

@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/cc-this5.scala:16:20 ----------------------------------------------------------
 16 |    def f = println(c)  // error
    |                    ^
-   |                    (c : Cap) cannot be referenced here; it is not included in the allowed capture set {}
+   |                    (c : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
    |                    of the enclosing class A
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-this5.scala:21:15 -------------------------------------
 21 |    val x: A = this // error

tests/neg-custom-args/captures/effect-swaps.check

@@ -22,3 +22,7 @@
 73 |            fr.await.ok
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/effect-swaps.scala:66:15 ------------------------------------------------------
+66 |        Result.make: // error
+   |        ^^^^^^^^^^^
+   |        escaping local reference contextual$9.type

tests/neg-custom-args/captures/effect-swaps.scala

@@ -63,7 +63,7 @@ def test[T, E](using Async) =
           fr.await.ok
 
     def fail4[T, E](fr: Future[Result[T, E]]^) =
-        Result.make: //lbl ?=> // should be error, escaping label from Result but infers Result[Any, Any]
+        Result.make: // error
           Future: fut ?=>
             fr.await.ok
 

tests/neg-custom-args/captures/extending-cap-classes.check

@@ -15,7 +15,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/extending-cap-classes.scala:13:15 ------------------------
 13 |  val z2: C1 = y2 // error
    |               ^^
-   |               Found:    (y2 : C2)^{y2}
+   |               Found:    (y2 : C2^)
    |               Required: C1
    |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/i16725.scala

@@ -7,8 +7,8 @@ type Wrapper[T] = [R] -> (f: T => R) -> R
 def mk[T](x: T): Wrapper[T] = [R] => f => f(x)
 def useWrappedIO(wrapper: Wrapper[IO]): () -> Unit =
   () =>
-    wrapper: io =>
+    wrapper: io =>  // error
       io.brewCoffee()
 def main(): Unit =
-  val escaped = usingIO(io => useWrappedIO(mk(io))) // error
+  val escaped = usingIO(io => useWrappedIO(mk(io)))
   escaped()  // boom