Changes to compiler codebase so that it passes capture checking

Author: odersky

compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala

@@ -36,6 +36,12 @@ class BootstrappedOnlyCompilationTests {
     ).checkCompile()
   }
 
+  @Test def posWithCompilerCC: Unit =
+    implicit val testGroup: TestGroup = TestGroup("compilePosWithCompilerCC")
+    aggregateTests(
+      compileDir("tests/pos-with-compiler-cc/dotc", withCompilerOptions.and("-language:experimental.captureChecking"))
+    ).checkCompile()
+
   @Test def posWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compilePosWithCompiler")
     aggregateTests(

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

@@ -31,6 +31,7 @@ import java.nio.charset.StandardCharsets
 import scala.collection.mutable
 import scala.util.control.NonFatal
 import scala.io.Codec
+import caps.unsafe.unsafeUnbox
 
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
@@ -270,7 +271,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       Rewrites.writeBack()
     suppressions.runFinished(hasErrors = ctx.reporter.hasErrors)
     while (finalizeActions.nonEmpty) {
-      val action = finalizeActions.remove(0)
+      val action = finalizeActions.remove(0).unsafeUnbox
       action()
     }
     compiling = false

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

@@ -673,7 +673,7 @@ object desugar {
       else (Nil, Nil)
     }
 
-    var parents1 = parents
+    var parents1: List[untpd.Tree] = parents // !cc! need explicit type to make capture checking pass
     if (isEnumCase && parents.isEmpty)
       parents1 = enumClassTypeRef :: Nil
     if (isNonEnumCase)
@@ -1779,7 +1779,10 @@ object desugar {
         val elems = segments flatMap {
           case ts: Thicket => ts.trees.tail
           case t => Nil
-        } map {
+        } map { (t: Tree) => t match
+            // !cc! explicitly typed parameter (t: Tree) is needed since otherwise
+            // we get an error similar to #16268. (The explicit type constrains the type of `segments`
+            // which is otherwise List[{*} tree])
           case Block(Nil, EmptyTree) => Literal(Constant(())) // for s"... ${} ..."
           case Block(Nil, expr) => expr // important for interpolated string as patterns, see i1773.scala
           case t => t

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

@@ -15,7 +15,7 @@ import annotation.internal.sharable
 
 /** A base class for things that have positions (currently: modifiers and trees)
  */
-abstract class Positioned(implicit @constructorOnly src: SourceFile) extends SrcPos, Product, Cloneable {
+abstract class Positioned(implicit @constructorOnly src: SourceFile) extends SrcPos, Product, Cloneable, caps.Pure {
   import Positioned.{ids, nextId, debugId}
 
   private var mySpan: Span = _

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

@@ -7,6 +7,7 @@ import Types._, Contexts._, Flags._
 import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
 import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
+import language.experimental.pureFunctions
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are
@@ -32,8 +33,8 @@ import dotty.tools.dotc.transform.SymUtils._
  *  set, we would get a data race assertion error.
  */
 class TreeTypeMap(
-  val typeMap: Type => Type = IdentityTypeMap,
-  val treeMap: tpd.Tree => tpd.Tree = identity _,
+  val typeMap: Type -> Type = IdentityTypeMap,
+  val treeMap: tpd.Tree -> tpd.Tree = identity[tpd.Tree](_), // !cc! need explicit instantiation of default argument
   val oldOwners: List[Symbol] = Nil,
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
@@ -42,8 +43,8 @@ class TreeTypeMap(
   import tpd._
 
   def copy(
-      typeMap: Type => Type,
-      treeMap: tpd.Tree => tpd.Tree,
+      typeMap: Type -> Type,
+      treeMap: tpd.Tree -> tpd.Tree,
       oldOwners: List[Symbol],
       newOwners: List[Symbol],
       substFrom: List[Symbol],

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

@@ -16,6 +16,8 @@ import annotation.internal.sharable
 import annotation.unchecked.uncheckedVariance
 import annotation.constructorOnly
 import Decorators._
+import annotation.retains
+import language.experimental.pureFunctions
 
 object Trees {
 
@@ -46,7 +48,7 @@ object Trees {
    *     nodes.
    */
   abstract class Tree[-T >: Untyped](implicit @constructorOnly src: SourceFile)
-  extends Positioned, SrcPos, Product, Attachment.Container, printing.Showable {
+  extends Positioned, SrcPos, Product, Attachment.Container, printing.Showable, caps.Pure {
 
     if (Stats.enabled) ntrees += 1
 
@@ -433,7 +435,7 @@ object Trees {
     def isBackquoted: Boolean = hasAttachment(Backquoted)
   }
 
-  class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name, expl: => String)(implicit @constructorOnly src: SourceFile)
+  class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name, expl: -> String)(implicit @constructorOnly src: SourceFile)
     extends Ident[T](name) {
     def explanation = expl
     override def toString: String = s"SearchFailureIdent($explanation)"
@@ -1520,7 +1522,7 @@ object Trees {
       }
     }
 
-    abstract class TreeAccumulator[X] { self =>
+    abstract class TreeAccumulator[X] { self: TreeAccumulator[X] @retains(caps.*) =>
       // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
       def apply(x: X, tree: Tree)(using Context): X
 

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

@@ -18,6 +18,7 @@ import typer.ConstFold
 
 import scala.annotation.tailrec
 import scala.collection.mutable.ListBuffer
+import language.experimental.pureFunctions
 
 /** Some creators for typed trees */
 object tpd extends Trees.Instance[Type] with TypedTreeInfo {
@@ -1454,7 +1455,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    * @return The symbols imported.
    */
   def importedSymbols(imp: Import,
-                      selectorPredicate: untpd.ImportSelector => Boolean = util.common.alwaysTrue)
+                      selectorPredicate: untpd.ImportSelector -> Boolean = util.common.alwaysTrue)
                      (using Context): List[Symbol] =
     imp.selectors.find(selectorPredicate) match
       case Some(sel) => importedSymbols(imp.expr, sel.name)

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

@@ -11,6 +11,8 @@ import util.Spans.Span
 import annotation.constructorOnly
 import annotation.internal.sharable
 import Decorators._
+import annotation.retains
+import language.experimental.pureFunctions
 
 object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
@@ -149,7 +151,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] -> Type)(implicit @constructorOnly src: SourceFile) extends Tree
 
   @sharable object EmptyTypeIdent extends Ident(tpnme.EMPTY)(NoSource) with WithoutTypeOrPos[Untyped] {
     override def isEmpty: Boolean = true
@@ -369,7 +371,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   // ------ Creation methods for untyped only -----------------
 
   def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)
-  def SearchFailureIdent(name: Name, explanation: => String)(implicit src: SourceFile): SearchFailureIdent = new SearchFailureIdent(name, explanation)
+  def SearchFailureIdent(name: Name, explanation: -> String)(implicit src: SourceFile): SearchFailureIdent = new SearchFailureIdent(name, explanation)
   def Select(qualifier: Tree, name: Name)(implicit src: SourceFile): Select = new Select(qualifier, name)
   def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit src: SourceFile): Select = new SelectWithSig(qualifier, name, sig)
   def This(qual: Ident)(implicit src: SourceFile): This = new This(qual)
@@ -731,7 +733,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     }
   }
 
-  abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] { self =>
+  abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] {
+    self: UntypedTreeAccumulator[X] @retains(caps.*) =>
     override def foldMoreCases(x: X, tree: Tree)(using Context): X = tree match {
       case ModuleDef(name, impl) =>
         this(x, impl)

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

@@ -16,6 +16,7 @@ import util.{SimpleIdentitySet, Property}
 import util.common.alwaysTrue
 import scala.collection.mutable
 import config.Config.ccAllowUnsoundMaps
+import language.experimental.pureFunctions
 
 /** A class for capture sets. Capture sets can be constants or variables.
  *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
@@ -37,7 +38,7 @@ import config.Config.ccAllowUnsoundMaps
  *  if the mapped function is either a bijection or if it is idempotent
  *  on capture references (c.f. doc comment on `map` below).
  */
-sealed abstract class CaptureSet extends Showable:
+sealed abstract class CaptureSet extends Showable, caps.Pure:
   import CaptureSet.*
 
   /** The elements of this capture set. For capture variables,
@@ -222,7 +223,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: CaptureRef -> Boolean)(using Context): CaptureSet =
     if this.isConst then
       val elems1 = elems.filter(p)
       if elems1 == elems then this
@@ -377,8 +378,10 @@ object CaptureSet:
     def isConst = isSolved
     def isAlwaysEmpty = false
 
-    /** A handler to be invoked if the root reference `*` is added to this set */
-    var rootAddedHandler: () => Context ?=> Unit = () => ()
+    /** A handler to be invoked if the root reference `*` is added to this set
+     *  The handler is pure in the sense that it will only output diagnostics.
+     */
+    var rootAddedHandler: () -> Context ?-> Unit = () => ()
 
     var description: String = ""
 
@@ -426,7 +429,7 @@ object CaptureSet:
       else
         CompareResult.fail(this)
 
-    override def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
+    override def disallowRootCapability(handler: () -> Context ?-> Unit)(using Context): this.type =
       rootAddedHandler = handler
       super.disallowRootCapability(handler)
 
@@ -618,7 +621,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: 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/cc/CheckCaptures.scala

@@ -21,6 +21,7 @@ import CaptureSet.{withCaptureSetsExplained, IdempotentCaptRefMap}
 import StdNames.nme
 import NameKinds.DefaultGetterName
 import reporting.trace
+import language.experimental.pureFunctions
 
 /** The capture checker */
 object CheckCaptures:
@@ -719,20 +720,21 @@ 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 => x): ((Type, CaptureSet, Boolean), Type => Type) =
+      def destructCapturingType(tp: Type, reconstruct: Type -> Type = (x: Type) => x) // !cc! need monomorphic default argument
+          : (Type, CaptureSet, Boolean, Type -> Type) =
         tp.dealias match
           case tp @ CapturingType(parent, cs) =>
             if parent.dealias.isCapturingType then
               destructCapturingType(parent, res => reconstruct(tp.derivedCapturingType(res, cs)))
             else
-              ((parent, cs, tp.isBoxed), reconstruct)
+              (parent, cs, tp.isBoxed, reconstruct)
           case actual =>
-            ((actual, CaptureSet(), false), reconstruct)
+            (actual, CaptureSet(), false, reconstruct)
 
       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) = destructCapturingType(actual)
+          val (parent, cs, actualIsBoxed, recon: (Type -> Type)) = destructCapturingType(actual)
 
           val needsAdaptation = actualIsBoxed != expected.isBoxedCapturing
           val insertBox = needsAdaptation && covariant != actualIsBoxed