A first, incomplete implementation of polyadic capture calculus

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -4,7 +4,6 @@ package dotc
 import core._
 import Contexts._
 import typer.{TyperPhase, RefChecks}
-import cc.CheckCaptures
 import parsing.Parser
 import Phases.Phase
 import transform._
@@ -84,8 +83,9 @@ class Compiler {
          new PatternMatcher) ::      // Compile pattern matches
     List(new TestRecheck.Pre) ::     // Test only: run rechecker, enabled under -Yrecheck-test
     List(new TestRecheck) ::         // Test only: run rechecker, enabled under -Yrecheck-test
-    List(new CheckCaptures.Pre) ::   // Preparations for check captures phase, enabled under captureChecking
-    List(new CheckCaptures) ::       // Check captures, enabled under captureChecking
+    List(new cc.AddTryOwners) ::     // Add symbols as owners of try blocks, enabled under captureChecking
+    List(new cc.Setup) ::            // Preparations for check captures phase, enabled under captureChecking
+    List(new cc.CheckCaptures) ::    // Check captures, enabled under captureChecking
     List(new ElimOpaque,             // Turn opaque into normal aliases
          new sjs.ExplicitJSClasses,  // Make all JS classes explicit (Scala.js only)
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1284,6 +1284,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       !(sym.is(Method) && sym.info.isInstanceOf[MethodOrPoly]) // if is a method it is parameterless
   }
 
+  /** A tree traverser that generates the the same import contexts as original typer for statements.
+   *  TODO: Should we align TreeMapWithPreciseStatContexts and also keep track of exprOwners?
+   */
+  abstract class TreeTraverserWithPreciseImportContexts extends TreeTraverser:
+    override def apply(x: Unit, trees: List[Tree])(using Context): Unit =
+      def recur(trees: List[Tree]): Unit = trees match
+        case (imp: Import) :: rest =>
+          traverse(rest)(using ctx.importContext(imp, imp.symbol))
+        case tree :: rest =>
+          traverse(tree)
+          traverse(rest)
+        case Nil =>
+      recur(trees)
+  end TreeTraverserWithPreciseImportContexts
+
   extension (xs: List[tpd.Tree])
     def tpes: List[Type] = xs match {
       case x :: xs1 => x.tpe :: xs1.tpes

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

@@ -0,0 +1,46 @@
+package dotty.tools.dotc
+package cc
+
+import core.*
+import DenotTransformers.IdentityDenotTransformer
+import Phases.Phase
+import Contexts.*, Symbols.*, Flags.*, Types.*
+import config.Feature
+import ast.tpd
+import StdNames.nme
+import Decorators.i
+
+object AddTryOwners:
+  val name: String = "addTryOwners"
+  val description: String = "add symbols for try blocks in preparation of capture checking"
+
+class AddTryOwners extends Phase, IdentityDenotTransformer:
+  thisPhase =>
+
+  import tpd.*
+
+  override def phaseName: String = AddTryOwners.name
+  override def description: String = AddTryOwners.description
+
+  override def isRunnable(using Context) =
+    super.isRunnable && Feature.ccEnabledSomewhere
+
+  override def isCheckable = false
+
+  def run(using Context): Unit =
+    val addTryOwners = new TreeTraverserWithPreciseImportContexts:
+      def traverse(tree: Tree)(using Context): Unit = tree match
+        case tree @ Try(expr, cases, finalizer) if Feature.enabled(Feature.saferExceptions) =>
+          val tryOwner = newSymbol(ctx.owner, nme.TRY_BLOCK, SyntheticMethod, MethodType(Nil, defn.UnitType))
+          ccState.tryBlockOwner(tree) = tryOwner
+          ccState.isLevelOwner(tryOwner) = true
+          expr.changeOwnerAfter(ctx.owner, tryOwner, thisPhase)
+          inContext(ctx.withOwner(tryOwner)):
+            traverse(expr)
+          traverse(cases)
+          traverse(finalizer)
+        case _ =>
+          traverseChildren(tree)
+    addTryOwners.traverse(ctx.compilationUnit.tpdTree)
+end AddTryOwners
+

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

@@ -24,8 +24,17 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
   import CaptureAnnotation.*
   import tpd.*
 
-  /** A cache for boxed version of a capturing type with this annotation */
-  val boxedType = BoxedTypeCache()
+  /** A cache for the version of this annotation which differs in its boxed status. */
+  var boxDual: CaptureAnnotation | Null = null
+
+  /** A boxed annotation which is either the same annotation or its boxDual */
+  def boxedAnnot(using Context): CaptureAnnotation =
+    if boxed then this
+    else if boxDual != null then boxDual.nn
+    else
+      val dual = CaptureAnnotation(refs, boxed = true)(cls)
+      dual.boxDual = this
+      dual
 
   /** Reconstitute annotation tree from capture set */
   override def tree(using Context) =