CC-UPDATE: Make Context a capability

A version of the test compiler where contexts are tracked as capabilities.

Two versions: Context (tracked in arena) and DetachedContext (pure, free in heap).
DetachedCOntext is an opaque type. This ensures that we do not accidentally treat
an arena-allocated FreshContext as a DetachedContext

Author: odersky

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

@@ -222,7 +222,7 @@ sealed abstract class CaptureSet extends Showable:
   /** The largest subset (via <:<) of this capture set that only contains elements
    *  for which `p` is true.
    */
-  def filter(p: CaptureRef => Boolean)(using Context): CaptureSet =
+  def filter(p: Context ?=> CaptureRef => Boolean)(using Context): CaptureSet =
     if this.isConst then
       val elems1 = elems.filter(p)
       if elems1 == elems then this
@@ -613,7 +613,7 @@ object CaptureSet:
 
   /** A variable with elements given at any time as { x <- source.elems | p(x) } */
   class Filtered private[CaptureSet]
-    (val source: Var, p: CaptureRef => Boolean)(using @constructorOnly ctx: Context)
+    (val source: Var, p: Context ?=> CaptureRef => Boolean)(using @constructorOnly ctx: Context)
   extends DerivedVar(source.elems.filter(p)):
 
     override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =

tests/pos-with-compiler-cc/dotc/Driver.scala

@@ -69,7 +69,7 @@ class Driver {
    *  this method returns a list of files to compile and an updated Context.
    *  If compilation should be interrupted, this method returns None.
    */
-  def setup(args: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
+  def setup(args: Array[String], rootCtx: Context): Option[(List[AbstractFile], DetachedContext)] = {
     val ictx = rootCtx.fresh
     val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
     ictx.setSettings(summary.sstate)
@@ -83,7 +83,7 @@ class Driver {
       val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState)
       fileNamesOrNone.map { fileNames =>
         val files = fileNames.map(ctx.getFile)
-        (files, fromTastySetup(files))
+        (files, fromTastySetup(files).detach)
       }
     }
   }

tests/pos-with-compiler-cc/dotc/Resident.scala

@@ -45,10 +45,10 @@ class Resident extends Driver {
           inContext(ctx) {
             doCompile(residentCompiler, files)
           }
-          var nextCtx = ctx
+          var nextCtx: DetachedContext = ctx
           var line = getLine()
           while (line == reset) {
-            nextCtx = rootCtx
+            nextCtx = rootCtx.detach
             line = getLine()
           }
           if line.startsWith(quit) then ctx.reporter

tests/pos-with-compiler-cc/dotc/Run.scala

@@ -31,10 +31,13 @@ import java.nio.charset.StandardCharsets
 import scala.collection.mutable
 import scala.util.control.NonFatal
 import scala.io.Codec
+import annotation.constructorOnly
 import caps.unsafe.unsafeUnbox
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+
+  val ictx = ictx0.detach
 
   /** Default timeout to stop looking for further implicit suggestions, in ms.
    *  This is usually for the first import suggestion; subsequent suggestions
@@ -176,7 +179,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   def compile(files: List[AbstractFile]): Unit =
     try
-      val sources = files.map(runContext.getSource(_))
+      val codec = Codec(runContext.settings.encoding.value)
+      val sources = files.map(runContext.getSource(_, codec))
       compileSources(sources)
     catch
       case NonFatal(ex) =>
@@ -286,7 +290,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
 
-      val unit = CompilationUnit(ctx.getSource(file))
+      val codec = Codec(ctx.settings.encoding.value)
+      val unit = CompilationUnit(ctx.getSource(file, codec))
       val unitCtx = runContext.fresh
         .setCompilationUnit(unit)
         .withRootImports
@@ -368,7 +373,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *                 for type checking.
    *    imports      For each element of RootImports, an import context
    */
-  protected def rootContext(using Context): Context = {
+  protected def rootContext(using Context): DetachedContext = {
     ctx.initialize()
     ctx.base.setPhasePlan(comp.phases)
     val rootScope = new MutableScope(0)
@@ -387,12 +392,12 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
     // `this` must be unchecked for safe initialization because by being passed to setRun during
     // initialization, it is not yet considered fully initialized by the initialization checker
-    start.setRun(this: @unchecked)
+    start.setRun(this: @unchecked).detach
   }
 
-  private var myCtx: Context | Null = rootContext(using ictx)
+  private var myCtx: DetachedContext | Null = rootContext(using ictx)
 
   /** The context created for this run */
-  given runContext[Dummy_so_its_a_def]: Context = myCtx.nn
+  given runContext[Dummy_so_its_a_def]: DetachedContext = myCtx.nn
   assert(runContext.runId <= Periods.MaxPossibleRunId)
 }

tests/pos-with-compiler-cc/dotc/ast/Desugar.scala

@@ -109,11 +109,12 @@ object desugar {
      *  from subclasses.
      */
     def derivedTree(sym: Symbol)(using Context): tpd.TypeTree = {
-      val relocate = new TypeMap {
+      val dctx = ctx.detach
+      val relocate = new TypeMap(using dctx) {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
-            val defctx = mapCtx.outersIterator.dropWhile(_.scope eq mapCtx.scope).next()
+            val defctx = mapCtx.detach.outersIterator.dropWhile(_.scope eq mapCtx.scope).next()
             var local = defctx.denotNamed(tp.name).suchThat(_.isParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealiasKeepAnnots
             else {
@@ -1388,7 +1389,7 @@ object desugar {
    */
   def packageDef(pdef: PackageDef)(using Context): PackageDef = {
     checkPackageName(pdef)
-    val wrappedTypeNames = pdef.stats.collect {
+    val wrappedTypeNames = pdef.stats.collectCC {
       case stat: TypeDef if isTopLevelDef(stat) => stat.name
     }
     def inPackageObject(stat: Tree) =

tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala

@@ -39,7 +39,7 @@ class TreeTypeMap(
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
   val substTo: List[Symbol] = Nil,
-  cpy: tpd.TreeCopier = tpd.cpy)(using Context) extends tpd.TreeMap(cpy) {
+  cpy: tpd.TreeCopier = tpd.cpy)(using DetachedContext) extends tpd.TreeMap(cpy) {
   import tpd._
 
   def copy(

tests/pos-with-compiler-cc/dotc/ast/tpd.scala

@@ -438,7 +438,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private def followOuterLinks(t: Tree)(using Context) = t match {
     case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
       // after erasure outer paths should be respected
-      ExplicitOuter.OuterOps(ctx).path(toCls = t.tpe.classSymbol)
+      ExplicitOuter.OuterOps(ctx.detach).path(toCls = t.tpe.classSymbol)
     case t =>
       t
   }

tests/pos-with-compiler-cc/dotc/ast/untpd.scala

@@ -38,7 +38,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   object TypedSplice {
     def apply(tree: tpd.Tree, isExtensionReceiver: Boolean = false)(using Context): TypedSplice =
-      new TypedSplice(tree)(ctx.owner, isExtensionReceiver) {}
+      val owner = ctx.owner
+      given SourceFile = ctx.source
+      new TypedSplice(tree)(owner, isExtensionReceiver) {}
   }
 
   /** mods object name impl */
@@ -152,7 +154,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
 
   /** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
-  case class DependentTypeTree(tp: List[Symbol] -> Type)(implicit @constructorOnly src: SourceFile) extends Tree
+  case class DependentTypeTree(tp: List[Symbol] -> Context ?-> Type)(implicit @constructorOnly src: SourceFile) extends Tree
 
   @sharable object EmptyTypeIdent extends Ident(tpnme.EMPTY)(NoSource) with WithoutTypeOrPos[Untyped] {
     override def isEmpty: Boolean = true

tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala

@@ -17,6 +17,7 @@ import util.common.alwaysTrue
 import scala.collection.mutable
 import config.Config.ccAllowUnsoundMaps
 import language.experimental.pureFunctions
+import annotation.retains
 
 /** A class for capture sets. Capture sets can be constants or variables.
  *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
@@ -176,7 +177,7 @@ sealed abstract class CaptureSet extends Showable, caps.Pure:
       case Nil =>
         addDependent(that)
     recur(elems.toList)
-      .showing(i"subcaptures $this <:< $that = ${result.show}", capt)
+      .showing(i"subcaptures $this <:< $that = $result", capt)(using null)
 
   /** Two capture sets are considered =:= equal if they mutually subcapture each other
    *  in a frozen state.
@@ -223,7 +224,7 @@ sealed abstract class CaptureSet extends Showable, caps.Pure:
   /** The largest subset (via <:<) of this capture set that only contains elements
    *  for which `p` is true.
    */
-  def filter(p: CaptureRef -> Boolean)(using Context): CaptureSet =
+  def filter(p: (c: Context) ?-> (CaptureRef -> Boolean) @retains(c))(using Context): CaptureSet =
     if this.isConst then
       val elems1 = elems.filter(p)
       if elems1 == elems then this
@@ -269,7 +270,7 @@ sealed abstract class CaptureSet extends Showable, caps.Pure:
 
   /** A mapping resulting from substituting parameters of a BindingType to a list of types */
   def substParams(tl: BindingType, to: List[Type])(using Context) =
-    map(Substituters.SubstParamsMap(tl, to))
+    map(Substituters.SubstParamsMap(tl, to).detach)
 
   /** Invoke handler if this set has (or later aquires) the root capability `*` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
@@ -596,7 +597,7 @@ object CaptureSet:
         super.addNewElems(newElems, origin)
           .andAlso {
             source.tryInclude(newElems.map(bimap.backward), this)
-              .showing(i"propagating new elems ${CaptureSet(newElems)} backward from $this to $source", capt)
+              .showing(i"propagating new elems ${CaptureSet(newElems)} backward from $this to $source", capt)(using null)
           }
 
     /** For a BiTypeMap, supertypes of the mapped type also constrain
@@ -608,15 +609,15 @@ object CaptureSet:
      */
     override def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
       val supApprox = super.computeApprox(this)
-      if source eq origin then supApprox.map(bimap.inverseTypeMap)
+      if source eq origin then supApprox.map(bimap.inverseTypeMap.detach)
       else source.upperApprox(this).map(bimap) ** supApprox
 
     override def toString = s"BiMapped$id($source, elems = $elems)"
   end BiMapped
 
   /** A variable with elements given at any time as { x <- source.elems | p(x) } */
   class Filtered private[CaptureSet]
-    (val source: Var, p: CaptureRef -> Boolean)(using @constructorOnly ctx: Context)
+    (val source: Var, p: (c: Context) ?-> (CaptureRef -> Boolean) @retains(c))(using @constructorOnly ctx: Context)
   extends DerivedVar(source.elems.filter(p)):
 
     override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
@@ -644,10 +645,10 @@ object CaptureSet:
   end Filtered
 
   /** A variable with elements given at any time as { x <- source.elems | !other.accountsFor(x) } */
-  class Diff(source: Var, other: Const)(using Context)
+  class Diff(source: Var, other: Const)(using @constructorOnly ctx: Context)
   extends Filtered(source, !other.accountsFor(_))
 
-  class Intersected(cs1: CaptureSet, cs2: CaptureSet)(using Context)
+  class Intersected(cs1: CaptureSet, cs2: CaptureSet)(using @constructorOnly ctx: Context)
   extends Var(elemIntersection(cs1, cs2)):
     addAsDependentTo(cs1)
     addAsDependentTo(cs2)

tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala

@@ -71,7 +71,7 @@ object CheckCaptures:
    *  maps parameters in contravariant capture sets to the empty set.
    *  TODO: check what happens with non-variant.
    */
-  final class SubstParamsMap(from: BindingType, to: List[Type])(using Context)
+  final class SubstParamsMap(from: BindingType, to: List[Type])(using DetachedContext)
   extends ApproximatingTypeMap, IdempotentCaptRefMap:
     def apply(tp: Type): Type = tp match
       case tp: ParamRef =>
@@ -138,7 +138,7 @@ class CheckCaptures extends Recheck, SymTransformer:
   def phaseName: String = "cc"
   override def isEnabled(using Context) = true
 
-  def newRechecker()(using Context) = CaptureChecker(ctx)
+  def newRechecker()(using Context) = CaptureChecker(ctx.detach)
 
   override def run(using Context): Unit =
     if Feature.ccEnabled then
@@ -161,7 +161,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ =>
       traverseChildren(t)
 
-  class CaptureChecker(ictx: Context) extends Rechecker(ictx):
+  class CaptureChecker(ictx: DetachedContext) extends Rechecker(ictx):
     import ast.tpd.*
 
     override def keepType(tree: Tree) =
@@ -194,7 +194,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     private def interpolateVarsIn(tpt: Tree)(using Context): Unit =
       if tpt.isInstanceOf[InferredTypeTree] then
         interpolator().traverse(tpt.knownType)
-          .showing(i"solved vars in ${tpt.knownType}", capt)
+          .showing(i"solved vars in ${tpt.knownType}", capt)(using null)
 
     /** Assert subcapturing `cs1 <: cs2` */
     def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
@@ -739,8 +739,8 @@ class CheckCaptures extends Recheck, SymTransformer:
        *  the innermost capturing type. The outer capture annotations can be
        *  reconstructed with the returned function.
        */
-      def destructCapturingType(tp: Type, reconstruct: Type -> Type = (x: Type) => x) // !cc! need monomorphic default argument
-          : (Type, CaptureSet, Boolean, Type -> Type) =
+      def destructCapturingType(tp: Type, reconstruct: Type -> Context ?-> Type = (x: Type) => x) // !cc! need monomorphic default argument
+          : (Type, CaptureSet, Boolean, Type -> Context ?-> Type) =
         tp.dealias match
           case tp @ CapturingType(parent, cs) =>
             if parent.dealias.isCapturingType then
@@ -753,7 +753,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       def adapt(actual: Type, expected: Type, covariant: Boolean): Type = trace(adaptInfo(actual, expected, covariant), recheckr, show = true) {
         if expected.isInstanceOf[WildcardType] then actual
         else
-          val (parent, cs, actualIsBoxed, recon: (Type -> Type)) = destructCapturingType(actual)
+          val (parent, cs, actualIsBoxed, recon: (Type -> Context ?-> Type)) = destructCapturingType(actual)
 
           val needsAdaptation = actualIsBoxed != expected.isBoxedCapturing
           val insertBox = needsAdaptation && covariant != actualIsBoxed

tests/pos-with-compiler-cc/dotc/cc/Setup.scala

@@ -81,7 +81,7 @@ extends tpd.TreeTraverser:
     *
     *  Polytype bounds are only cleaned using step 1, but not otherwise transformed.
     */
-  private def mapInferred(using Context) = new TypeMap:
+  private def mapInferred(using DetachedContext) = new TypeMap:
 
     /** Drop @retains annotations everywhere */
     object cleanup extends TypeMap:
@@ -257,7 +257,7 @@ extends tpd.TreeTraverser:
       defn.FunctionOf(defn.CanThrowClass.typeRef.appliedTo(exc) :: Nil, res, isContextual = true, isErased = true)
     case _ => tp
 
-  private def expandThrowsAliases(using Context) = new TypeMap:
+  private def expandThrowsAliases(using DetachedContext) = new TypeMap:
     def apply(t: Type) = t match
       case _: AppliedType =>
         val t1 = expandThrowsAlias(t)
@@ -281,7 +281,7 @@ extends tpd.TreeTraverser:
    *
    *  TODO: Should we also propagate capture sets to the left?
    */
-  private def expandAbbreviations(using Context) = new TypeMap:
+  private def expandAbbreviations(using DetachedContext) = new TypeMap:
 
     /** Propagate `outerCs` as well as all tracked parameters as capture set to the result type
      *  of the dependent function type `tp`.
@@ -349,7 +349,7 @@ extends tpd.TreeTraverser:
    *  @param from  a list of lists of type or term parameter symbols of a curried method
    *  @param to    a list of method or poly types corresponding one-to-one to the parameter lists
    */
-  private class SubstParams(from: List[List[Symbol]], to: List[LambdaType])(using Context)
+  private class SubstParams(from: List[List[Symbol]], to: List[LambdaType])(using DetachedContext)
   extends DeepTypeMap, BiTypeMap:
 
     def apply(t: Type): Type = t match

tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala

@@ -12,7 +12,7 @@ object SJSPlatform {
     ctx.platform.asInstanceOf[SJSPlatform]
 }
 
-class SJSPlatform()(using Context) extends JavaPlatform {
+class SJSPlatform()(using DetachedContext) extends JavaPlatform {
 
   /** Scala.js-specific definitions. */
   val jsDefinitions: JSDefinitions = new JSDefinitions()

tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala

@@ -8,37 +8,38 @@ import Decorators._
 import collection.mutable
 import config.SourceVersion.future
 import config.Feature.sourceVersion
+import annotation.constructorOnly
 
 /** Realizability status */
 object CheckRealizable {
 
-  sealed abstract class Realizability(val msg: String) {
+  sealed abstract class Realizability(val msg: String) extends caps.Pure {
     def andAlso(other: => Realizability): Realizability =
       if (this == Realizable) other else this
-    def mapError(f: Realizability => Realizability): Realizability =
+    def mapError(f: Realizability -> Context ?-> Realizability)(using Context): Realizability =
       if (this == Realizable) this else f(this)
   }
 
   object Realizable extends Realizability("")
 
   object NotConcrete extends Realizability(" is not a concrete type")
 
-  class NotFinal(sym: Symbol)(using Context)
+  class NotFinal(sym: Symbol)(using @constructorOnly ctx: Context)
   extends Realizability(i" refers to nonfinal $sym")
 
-  class HasProblemBounds(name: Name, info: Type)(using Context)
+  class HasProblemBounds(name: Name, info: Type)(using @constructorOnly ctx: Context)
   extends Realizability(i" has a member $name with possibly conflicting bounds ${info.bounds.lo} <: ... <: ${info.bounds.hi}")
 
-  class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(using Context)
+  class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(using @constructorOnly ctx: Context)
   extends Realizability(i" has a base type $typ with possibly conflicting parameter bounds ${argBounds.lo} <: ... <: ${argBounds.hi}")
 
-  class HasProblemBase(base1: Type, base2: Type)(using Context)
+  class HasProblemBase(base1: Type, base2: Type)(using @constructorOnly ctx: Context)
   extends Realizability(i" has conflicting base types $base1 and $base2")
 
-  class HasProblemField(fld: SingleDenotation, problem: Realizability)(using Context)
+  class HasProblemField(fld: SingleDenotation, problem: Realizability)(using @constructorOnly ctx: Context)
   extends Realizability(i" has a member $fld which is not a legal path\nsince ${fld.symbol.name}: ${fld.info}${problem.msg}")
 
-  class ProblemInUnderlying(tp: Type, problem: Realizability)(using Context)
+  class ProblemInUnderlying(tp: Type, problem: Realizability)(using @constructorOnly ctx: Context)
   extends Realizability(i"s underlying type ${tp}${problem.msg}") {
     assert(problem != Realizable)
   }