New scheme

Author: odersky

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

@@ -83,7 +83,6 @@ 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 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

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

@@ -437,7 +437,7 @@ object desugar {
   private def toDefParam(tparam: TypeDef, keepAnnotations: Boolean): TypeDef = {
     var mods = tparam.rawMods
     if (!keepAnnotations) mods = mods.withAnnotations(Nil)
-    tparam.withMods(mods & EmptyFlags | Param)
+    tparam.withMods(mods & (EmptyFlags | Sealed) | Param)
   }
   private def toDefParam(vparam: ValDef, keepAnnotations: Boolean, keepDefault: Boolean): ValDef = {
     var mods = vparam.rawMods

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

@@ -99,31 +99,13 @@ trait FollowAliases extends TypeMap:
         if t2 ne t1 then return t2
       mapOver(t)
 
-class mapRoots(from0: CaptureRoot, to: CaptureRoot)(using Context) extends DeepTypeMap, BiTypeMap, FollowAliases:
-  val from = from0.followAlias
-
-  //override val toString = i"mapRoots($from, $to)"
-
-  def apply(t: Type): Type =
-    if t eq from then to
-    else t match
-      case t: CaptureRoot.Var if ccConfig.constrainRootsWhenMapping && t.unifiesWith(from) =>
-        to
-      case t @ Setup.Box(t1) =>
-        t.derivedBox(this(t1))
-      case _ =>
-        mapOverFollowingAliases(t)
-
-  def inverse = mapRoots(to, from)
-end mapRoots
-
 extension (tree: Tree)
 
   /** Map tree with CaptureRef type to its type, throw IllegalCaptureRef otherwise */
   def toCaptureRef(using Context): CaptureRef = tree match
     case QualifiedRoot(outer) =>
       ctx.owner.levelOwnerNamed(outer)
-        .orElse(defn.captureRoot) // non-existing outer roots are reported in Setup's checkQualifiedRoots
+        .orElse(defn.RootClass) // non-existing outer roots are reported in Setup's checkQualifiedRoots
         .localRoot.termRef
     case _ => tree.tpe match
       case ref: CaptureRef => ref
@@ -301,32 +283,6 @@ extension (tp: Type)
           mapOver(t)
     tm(tp)
 
-  def hasUniversalRootOf(sym: Symbol)(using Context): Boolean =
-
-    def isOwnRoot(tp: Type)(using Context): Boolean =
-      tp.isCapabilityClassRef
-      || tp.dealias.match
-        case tp: TermRef =>
-          tp.isGenericRootCapability || tp.localRootOwner == sym
-        case _ =>
-          false
-
-    tp.dealiasKeepAnnots match
-      case tp @ AnnotatedType(parent, annot) =>
-        val found = annot match
-          case CaptureAnnotation(refs, _) => refs.elems.exists(isOwnRoot(_))
-          case _ => annot.tree.retainedElems.exists(tree => isOwnRoot(tree.tpe))
-        found || parent.hasUniversalRootOf(sym)
-      case tp: TypeRef =>
-        tp.isRef(defn.Caps_Cap) || tp.isCapabilityClassRef
-      case tp: LazyRef =>
-        tp.ref.hasUniversalRootOf(sym)
-      case tp: TypeVar =>
-        tp.underlying.hasUniversalRootOf(sym)
-      case _ =>
-        tp.isCapabilityClassRef
-  end hasUniversalRootOf
-
 extension (cls: ClassSymbol)
 
   def pureBaseClass(using Context): Option[Symbol] =
@@ -382,19 +338,6 @@ extension (sym: Symbol)
     && sym != defn.Caps_unsafeBox
     && sym != defn.Caps_unsafeUnbox
 
-  def takesCappedParamIn(info: Type)(using Context): Boolean =
-    info.dealias.stripPoly match
-      case mt: MethodType =>
-        (mt.paramInfos.exists(_.hasUniversalRootOf(sym)) || takesCappedParamIn(mt.resType))
-          //.showing(i"takes capped param1 $sym: $mt = $result")
-      case AppliedType(fn, args) if defn.isFunctionClass(fn.typeSymbol) =>
-        args.init.exists(_.hasUniversalRootOf(sym)) || takesCappedParamIn(args.last)
-      case defn.RefinedFunctionOf(rinfo) =>
-        takesCappedParamIn(rinfo)
-          //.showing(i"takes capped param2 $sym: $rinfo = $result")
-      case _ =>
-        false
-
   def isTrackedSomewhere(using Context): Boolean =
     val search = new TypeAccumulator[Boolean]:
       def apply(found: Boolean, tp: Type) =
@@ -404,31 +347,18 @@ extension (sym: Symbol)
 
   // TODO Also include vals (right now they are manually entered in levelOwners by Setup)
   def isLevelOwner(using Context): Boolean =
-    val symd = sym.denot
-    def isCaseClassSynthetic = // TODO drop
-      symd.maybeOwner.isClass && symd.owner.is(Case) && symd.is(Synthetic) && symd.info.firstParamNames.isEmpty
-    def classQualifies =
-      if sym.isEffectivelyFinal then
-        takesCappedParamIn(symd.primaryConstructor.info)
-        || symd.asClass.givenSelfType.hasUniversalRootOf(sym)
-      else
-        !sym.isPureClass
-    def compute =
-      if symd.isClass then
-        symd.is(CaptureChecked) && classQualifies || symd.isRoot
-      else
-        (symd.is(Method, butNot = Accessor)
-          || symd.isTerm && !symd.isOneOf(TermParamOrAccessor | Mutable))
-        && (!symd.owner.isClass
-            || symd.owner.is(CaptureChecked)
-            || Synthetics.needsTransform(symd)
-            )
-        && (!symd.isAnonymousFunction || sym.definedLocalRoot.exists)
-        && takesCappedParamIn(symd.info)
-        && { ccSetup.println(i"Level owner $sym"); true }
-
-    ccState.isLevelOwner.getOrElseUpdate(sym, compute)
-  end isLevelOwner
+    sym.isClass
+    || sym.is(Method, butNot = Accessor)// && !sym.isAnonymousFunction // TODO enable?
+
+  /** The level owner enclosing `sym` which has the given name, or NoSymbol if none exists.
+   */
+  def levelOwnerNamed(name: String)(using Context): Symbol =
+    def recur(sym: Symbol): Symbol =
+      if sym.name.toString == name then
+        if sym.isLevelOwner then sym else NoSymbol
+      else if sym == defn.RootClass then NoSymbol
+      else recur(sym.owner)
+    recur(sym)
 
   /** The owner of the current level. Qualifying owners are
    *   - methods other than constructors and anonymous functions
@@ -444,20 +374,6 @@ extension (sym: Symbol)
       else recur(sym.owner)
     recur(sym)
 
-  /** The level owner enclosing `sym` which has the given name, or NoSymbol if none exists.
-   *  If name refers to a val that has a closure as rhs, we return the closure as level
-   *  owner.
-   */
-  def levelOwnerNamed(name: String)(using Context): Symbol =
-    def recur(sym: Symbol): Symbol =
-      if sym.name.toString == name then
-        if sym.isLevelOwner then sym
-        else NoSymbol
-      else if sym == defn.RootClass then NoSymbol
-      else recur(sym.owner)
-    recur(sym)
-      .showing(i"find outer $sym [ $name ] = $result", capt)
-
   /** The parameter with type caps.Cap in the leading term parameter section,
    *  or NoSymbol, if none exists.
    */

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

@@ -59,7 +59,7 @@ object CaptureRoot:
      */
     def freshEnclosedBy(rs: CaptureRoot*)(using Context): CaptureRoot =
       val r = fresh
-      if rs.forall(_.encloses(r)) then r else throw NoCommonRoot(rs*)
+      if rs.forall(_.encloses(r)) then r else throw CaptureRoot.NoCommonRoot(rs*)
 
     def computeHash(bs: Binders): Int = hash
     def hash: Int = System.identityHashCode(this)
@@ -107,7 +107,7 @@ object CaptureRoot:
             r1.alias = r2
             r2.outerLimit =
               r1.outerLimit.maxNested(r2.outerLimit,
-                onConflict = (_, _) => throw NoCommonRoot(r1, r2))
+                onConflict = (_, _) => throw CaptureRoot.NoCommonRoot(r1, r2))
             r2.innerLimit = r1.innerLimit.minNested(r2.innerLimit)
             true
           else
@@ -129,7 +129,7 @@ object CaptureRoot:
     else (r1, r2) match
       case (r1: TermRef, r2: TermRef) =>
         r1.localRootOwner.maxNested(r2.localRootOwner,
-          onConflict = (_, _) => throw NoCommonRoot(r1, r2)
+          onConflict = (_, _) => throw CaptureRoot.NoCommonRoot(r1, r2)
         ).termRef
       case (r1: TermRef, r2: Var) =>
         r2.freshEnclosedBy(r1, r2)

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

@@ -61,10 +61,6 @@ sealed abstract class CaptureSet extends Showable:
    */
   def levelLimit: Symbol
 
-  def rootSet(using Context): CaptureSet =
-    assert(levelLimit.exists, this)
-    levelLimit.localRoot.termRef.singletonCaptureSet
-
   /** Is this capture set definitely non-empty? */
   final def isNotEmpty: Boolean = !elems.isEmpty
 
@@ -144,16 +140,30 @@ sealed abstract class CaptureSet extends Showable:
   extension (x: CaptureRef)(using Context)
     private def subsumes(y: CaptureRef) =
       (x eq y)
+      || x.isSuperRootOf(y)
       || y.match
-          case y: TermRef => (y.prefix eq x) || y.isLocalRootCapability && x.isSuperRootOf(y)
-          case y: CaptureRoot.Var => x.isSuperRootOf(y)
+          case y: TermRef => y.prefix eq x
           case _ => false
       || (x.isGenericRootCapability || y.isRootCapability && x.isRootCapability)
           && ctx.property(LooseRootChecking).isDefined
 
-    private def isSuperRootOf(y: CaptureRoot) = x match
-      case x: CaptureRoot =>
-        x.isGenericRootCapability || x.isLocalRootCapability && y.encloses(x)
+    /** x <:< cap,   cap[x] <:< cap
+     *  cap[y] <:< cap[x] if y encloses x
+     *  y <:< cap[x] if y's level owner encloses x's local root owner
+     */
+    private def isSuperRootOf(y: CaptureRef): Boolean = x match
+      case x: TermRef =>
+        if x.isGenericRootCapability then true
+        else if x.isLocalRootCapability && !y.isGenericRootCapability then
+          val xowner = x.localRootOwner
+          y match
+            case y: TermRef =>
+              xowner.isContainedIn(y.symbol.levelOwner)
+            case y: ThisType =>
+              xowner.isContainedIn(y.cls)
+            case _ =>
+              false
+        else false
       case _ => false
   end extension
 
@@ -207,9 +217,10 @@ sealed abstract class CaptureSet extends Showable:
     def recur(elems: List[CaptureRef]): CompareResult = elems match
       case elem :: elems1 =>
         var result = that.tryInclude(elem, this)
-        if !result.isOK && !elem.isRootCapability && summon[VarState] != FrozenState then
+        if !result.isOK then
           ccState.levelError = ccState.levelError.orElse(result.levelError)
-          result = result.orElse(elem.captureSetOfInfo.subCaptures(that))
+          if !elem.isRootCapability && summon[VarState] != FrozenState then
+            result = result.orElse(elem.captureSetOfInfo.subCaptures(that))
         if result.isOK then
           recur(elems1)
         else
@@ -322,22 +333,6 @@ sealed abstract class CaptureSet extends Showable:
   def substParams(tl: BindingType, to: List[Type])(using Context) =
     map(Substituters.SubstParamsMap(tl, to))
 
-  /** The capture root that corresponds to this capture set. This is:
-   *    - if the capture set is a Var with a defined level limit, the
-   *      associated capture root,
-   *    - otherwise, if the set is nonempty, the innermost root such
-   *      that some element of the set subcaptures this root,
-   *    - otherwise, if the set is empty, `default`.
-   */
-  def impliedRoot(default: CaptureRoot)(using Context): CaptureRoot =
-    if levelLimit.exists then levelLimit.localRoot.termRef
-    else if elems.isEmpty then default
-    else elems.toList
-      .map:
-        case elem: CaptureRoot if elem.isLocalRootCapability => elem
-        case elem => elem.captureSetOfInfo.impliedRoot(default)
-      .reduce((x: CaptureRoot, y: CaptureRoot) => CaptureRoot.lub(x, y))
-
   /** Invoke handler if this set has (or later aquires) the root capability `cap` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
     if isUniversal then handler()
@@ -459,7 +454,7 @@ object CaptureSet:
       varId += 1
       varId
 
-    //assert(id != 95)
+    //assert(id != 40)
 
     override val levelLimit =
       if directOwner.exists then directOwner.levelOwner else NoSymbol
@@ -525,12 +520,15 @@ object CaptureSet:
         if elem.isGenericRootCapability then rootAddedHandler()
         newElemAddedHandler(elem)
         // assert(id != 5 || elems.size != 3, this)
-        (CompareResult.OK /: deps) { (r, dep) =>
+        val res = (CompareResult.OK /: deps) { (r, dep) =>
           r.andAlso(dep.tryInclude(elem, this))
         }.addToTrace(this)
+        if !res.isOK then elems -= elem
+        res
 
     private def levelOK(elem: CaptureRef)(using Context): Boolean =
-      !levelLimit.exists
+      if elem.isGenericRootCapability then !noUniversal
+      else !levelLimit.exists
       || elem.match
           case elem: TermRef =>
             var sym = elem.symbol
@@ -571,15 +569,15 @@ object CaptureSet:
       else if elems.exists(_.isRootCapability) then
         CaptureSet(elems.filter(_.isRootCapability).toList*)
       else if computingApprox then
-        rootSet
+        universal
       else
         computingApprox = true
         try computeApprox(origin).ensuring(_.isConst)
         finally computingApprox = false
 
     /** The intersection of all upper approximations of dependent sets */
     protected def computeApprox(origin: CaptureSet)(using Context): CaptureSet =
-      (rootSet /: deps) { (acc, sup) => acc ** sup.upperApprox(this) }
+      (universal /: deps) { (acc, sup) => acc ** sup.upperApprox(this) }
 
     /** Widen the variable's elements to its upper approximation and
      *  mark it as constant from now on. This is used for contra-variant type variables
@@ -720,7 +718,7 @@ object CaptureSet:
       if source eq origin then
         // it's a mapping of origin, so not a superset of `origin`,
         // therefore don't contribute to the intersection.
-        rootSet
+        universal
       else
         source.upperApprox(this).map(tm)
 
@@ -788,7 +786,7 @@ object CaptureSet:
       if source eq origin then
         // it's a filter of origin, so not a superset of `origin`,
         // therefore don't contribute to the intersection.
-        rootSet
+        universal
       else
         source.upperApprox(this).filter(p)
 
@@ -819,7 +817,7 @@ object CaptureSet:
       if (origin eq cs1) || (origin eq cs2) then
         // it's a combination of origin with some other set, so not a superset of `origin`,
         // therefore don't contribute to the intersection.
-        rootSet
+        universal
       else
         CaptureSet(elemIntersection(cs1.upperApprox(this), cs2.upperApprox(this)))
 
@@ -1010,10 +1008,6 @@ object CaptureSet:
   def ofInfo(ref: CaptureRef)(using Context): CaptureSet = ref match
     case ref: TermRef if ref.isRootCapability =>
       ref.singletonCaptureSet
-    case ref: TermRef if ref.symbol.isLevelOwner =>
-      ofType(ref.underlying, followResult = true).filter(
-        ref.symbol.localRoot.termRef != _)
-      // TODO: Can replace filter with - ref.symbol.localRoot.termRef when we drop level nesting
     case _ =>
       ofType(ref.underlying, followResult = true)
 
@@ -1095,12 +1089,18 @@ object CaptureSet:
     override def toAdd(using Context) =
       for CompareResult.LevelError(cs, ref) <- ccState.levelError.toList yield
         ccState.levelError = None
-        val levelStr = ref match
-          case ref: TermRef => i", defined in ${ref.symbol.maybeOwner}"
-          case _ => ""
-        i"""
-           |
-           |Note that reference ${ref}$levelStr
-           |cannot be included in outer capture set $cs which is associated with ${cs.levelLimit}"""
+        if ref.isGenericRootCapability then
+          i"""
+            |
+            |Note that the universal capability `cap`
+            |cannot be included in capture set $cs"""
+        else
+          val levelStr = ref match
+            case ref: TermRef => i", defined in ${ref.symbol.maybeOwner}"
+            case _ => ""
+          i"""
+            |
+            |Note that reference ${ref}$levelStr
+            |cannot be included in outer capture set $cs which is associated with ${cs.levelLimit}"""
 
 end CaptureSet