Introduce capability classifiers

Author: odersky

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

@@ -258,9 +258,11 @@ object Capabilities:
   trait Capability extends Showable:
 
     private var myCaptureSet: CaptureSet | Null = uninitialized
-    private var myCaptureSetValid: Validity = invalid
+    private var captureSetValid: Validity = invalid
     private var mySingletonCaptureSet: CaptureSet.Const | Null = null
     private var myDerived: List[DerivedCapability] = Nil
+    private var myClassifiers: Classifiers = UnknownClassifier
+    private var classifiersValid: Validity = invalid
 
     protected def cached[C <: DerivedCapability](newRef: C): C =
       def recur(refs: List[DerivedCapability]): C = refs match
@@ -292,10 +294,7 @@ object Capabilities:
       case Maybe(ref1) => Maybe(ref1.restrict(cls))
       case ReadOnly(ref1) => ReadOnly(ref1.restrict(cls).asInstanceOf[Restricted])
       case self @ Restricted(ref1, prevCls) =>
-        val combinedCls =
-          if prevCls.isSubClass(cls) then prevCls
-          else if cls.isSubClass(prevCls) then cls
-          else defn.NothingClass
+        val combinedCls = leastClassifier(prevCls, cls)
         if combinedCls == prevCls then self
         else cached(Restricted(ref1, combinedCls))
       case self: (ObjectCapability | RootCapability | Reach) => cached(Restricted(self, cls))
@@ -469,7 +468,7 @@ object Capabilities:
 
     def derivesFromCapability(using Context): Boolean = derivesFromCapTrait(defn.Caps_Capability)
     def derivesFromMutable(using Context): Boolean = derivesFromCapTrait(defn.Caps_Mutable)
-    def derivesFromSharedCapability(using Context): Boolean = derivesFromCapTrait(defn.Caps_SharedCapability)
+    def derivesFromSharable(using Context): Boolean = derivesFromCapTrait(defn.Caps_Sharable)
 
     /** The capture set consisting of exactly this reference */
     def singletonCaptureSet(using Context): CaptureSet.Const =
@@ -479,7 +478,7 @@ object Capabilities:
 
     /** The capture set of the type underlying this reference */
     def captureSetOfInfo(using Context): CaptureSet =
-      if myCaptureSetValid == currentId then myCaptureSet.nn
+      if captureSetValid == currentId then myCaptureSet.nn
       else if myCaptureSet.asInstanceOf[AnyRef] eq CaptureSet.Pending then CaptureSet.empty
       else
         myCaptureSet = CaptureSet.Pending
@@ -491,11 +490,60 @@ object Capabilities:
           myCaptureSet = null
         else
           myCaptureSet = computed
-          myCaptureSetValid = currentId
+          captureSetValid = currentId
         computed
 
+    /** The transitive classifiers of this capability. */
+    def transClassifiers(using Context): Classifiers =
+      def toClassifiers(cls: ClassSymbol): Classifiers =
+        if cls == defn.AnyClass then Unclassified
+        else ClassifiedAs(cls :: Nil)
+      if classifiersValid != currentId then
+        myClassifiers = this match
+          case self: FreshCap =>
+            toClassifiers(self.hiddenSet.classifier)
+          case self: RootCapability =>
+            Unclassified
+          case Restricted(_, cls) =>
+            assert(cls != defn.AnyClass)
+            if cls == defn.NothingClass then ClassifiedAs(Nil)
+            else ClassifiedAs(cls :: Nil)
+          case ReadOnly(ref1) =>
+            ref1.transClassifiers
+          case Maybe(ref1) =>
+            ref1.transClassifiers
+          case Reach(_) =>
+            captureSetOfInfo.transClassifiers
+          case self: CoreCapability =>
+            joinClassifiers(toClassifiers(self.classifier), captureSetOfInfo.transClassifiers)
+        if myClassifiers != UnknownClassifier then
+          classifiersValid == currentId
+      myClassifiers
+    end transClassifiers
+
+    def tryClassifyAs(cls: ClassSymbol)(using Context): Boolean =
+      cls == defn.AnyClass
+      || this.match
+        case self: FreshCap =>
+          self.hiddenSet.tryClassifyAs(cls)
+        case self: RootCapability =>
+          true
+        case Restricted(_, cls1) =>
+          assert(cls != defn.AnyClass)
+          cls1.isSubClass(cls)
+        case ReadOnly(ref1) =>
+          ref1.tryClassifyAs(cls)
+        case Maybe(ref1) =>
+          ref1.tryClassifyAs(cls)
+        case Reach(_) =>
+          captureSetOfInfo.tryClassifyAs(cls)
+        case self: CoreCapability =>
+          self.classifier.isSubClass(cls)
+          && captureSetOfInfo.tryClassifyAs(cls)
+
     def invalidateCaches() =
-      myCaptureSetValid = invalid
+      captureSetValid = invalid
+      classifiersValid = invalid
 
     /**  x subsumes x
      *   x =:= y       ==>  x subsumes y
@@ -603,12 +651,15 @@ object Capabilities:
 
           vs.ifNotSeen(this)(x.hiddenSet.elems.exists(_.subsumes(y)))
           || levelOK
+              && ( y.tryClassifyAs(x.hiddenSet.classifier)
+                   || { capt.println(i"$y is not classified as $x"); false }
+              )
               && canAddHidden
               && vs.addHidden(x.hiddenSet, y)
         case x: ResultCap =>
           val result = y match
             case y: ResultCap => vs.unify(x, y)
-            case _ => y.derivesFromSharedCapability
+            case _ => y.derivesFromSharable
           if !result then
             TypeComparer.addErrorNote(CaptureSet.ExistentialSubsumesFailure(x, y))
           result
@@ -618,7 +669,7 @@ object Capabilities:
             case _: ResultCap => false
             case _: FreshCap if CCState.collapseFresh => true
             case _ =>
-              y.derivesFromSharedCapability
+              y.derivesFromSharable
               || canAddHidden && vs != VarState.HardSeparate && CCState.capIsRoot
         case _ =>
           y match
@@ -674,6 +725,39 @@ object Capabilities:
     def toText(printer: Printer): Text = printer.toTextCapability(this)
   end Capability
 
+  /** Result type of `transClassifiers`. Interprete as follows:
+   *    UnknownClassifier: No list could be computed since some capture sets
+   *                       are still unsolved variables
+   *    Unclassified     : No set exists since some parts of tcs are not classified
+   *    ClassifiedAs(clss: All parts of tcss are classified with classes in clss
+   */
+  enum Classifiers:
+    case UnknownClassifier
+    case Unclassified
+    case ClassifiedAs(clss: List[ClassSymbol])
+
+  export Classifiers.{UnknownClassifier, Unclassified, ClassifiedAs}
+
+  /** The least classifier between `cls1` and `cls2`, which are either
+   *  AnyClass, NothingClass, or a class directly extending caps.Classifier.
+   *  @return if oen of cls1, cls2 is a subclass of the other, the subclass
+   *          otherwise NothingClass (which is a subclass of all classes)
+   */
+  def leastClassifier(cls1: ClassSymbol, cls2: ClassSymbol)(using Context): ClassSymbol =
+    if cls1.isSubClass(cls2) then cls1
+    else if cls2.isSubClass(cls1) then cls2
+    else defn.NothingClass
+
+  def joinClassifiers(cs1: Classifiers, cs2: Classifiers)(using Context): Classifiers =
+    // Drop classes that subclass classes of the other set
+    def filterSub(cs1: List[ClassSymbol], cs2: List[ClassSymbol]) =
+      cs1.filter(cls1 => !cs2.exists(cls2 => cls1.isSubClass(cls2)))
+    (cs1, cs2) match
+      case (Unclassified, _) | (_, Unclassified) => Unclassified
+      case (UnknownClassifier, _) | (_, UnknownClassifier) => UnknownClassifier
+      case (ClassifiedAs(cs1), ClassifiedAs(cs2)) =>
+        ClassifiedAs(filterSub(cs1, cs2) ++ filterSub(cs2, cs1))
+
   /** The place of - and cause for - creating a fresh capability. Used for
    *  error diagnostics
    */

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

@@ -378,7 +378,7 @@ extension (tp: Type)
 
   def derivesFromCapability(using Context): Boolean = derivesFromCapTrait(defn.Caps_Capability)
   def derivesFromMutable(using Context): Boolean = derivesFromCapTrait(defn.Caps_Mutable)
-  def derivesFromSharedCapability(using Context): Boolean = derivesFromCapTrait(defn.Caps_SharedCapability)
+  def derivesFromSharedCapability(using Context): Boolean = derivesFromCapTrait(defn.Caps_Sharable)
 
   /** Drop @retains annotations everywhere */
   def dropAllRetains(using Context): Type = // TODO we should drop retains from inferred types before unpickling
@@ -444,6 +444,30 @@ extension (tp: Type)
   def dropUseAndConsumeAnnots(using Context): Type =
     tp.dropAnnot(defn.UseAnnot).dropAnnot(defn.ConsumeAnnot)
 
+  /** If `tp` is a function or method, a type of the same kind with the given
+   *  argument and result types.
+  */
+  def derivedFunctionOrMethod(argTypes: List[Type], resType: Type)(using Context): Type = tp match
+    case tp @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp) =>
+      val args1 = argTypes :+ resType
+      if args.corresponds(args1)(_ eq _) then tp
+      else tp.derivedAppliedType(tycon, args1)
+    case tp @ defn.RefinedFunctionOf(rinfo) =>
+      val rinfo1 = rinfo.derivedFunctionOrMethod(argTypes, resType)
+      if rinfo1 eq rinfo then tp
+      else if rinfo1.isInstanceOf[PolyType] then tp.derivedRefinedType(refinedInfo = rinfo1)
+      else rinfo1.toFunctionType(alwaysDependent = true)
+    case tp: MethodType =>
+      tp.derivedLambdaType(paramInfos = argTypes, resType = resType)
+    case tp: PolyType =>
+      assert(argTypes.isEmpty)
+      tp.derivedLambdaType(resType = resType)
+    case _ =>
+      tp
+
+  def classifier(using Context): ClassSymbol =
+    tp.classSymbols.map(_.classifier).foldLeft(defn.AnyClass)(leastClassifier)
+
 extension (tp: MethodType)
   /** A method marks an existential scope unless it is the prefix of a curried method */
   def marksExistentialScope(using Context): Boolean =
@@ -475,6 +499,16 @@ extension (cls: ClassSymbol)
       val selfType = bc.givenSelfType
       bc.is(CaptureChecked) && selfType.exists && selfType.captureSet.elems == refs.elems
 
+  def isClassifiedCapabilityClass(using Context): Boolean =
+    cls.derivesFrom(defn.Caps_Capability) && cls.parentSyms.contains(defn.Caps_Classifier)
+
+  def classifier(using Context): ClassSymbol =
+    if cls.derivesFrom(defn.Caps_Capability) then
+      cls.baseClasses
+        .filter(_.parentSyms.contains(defn.Caps_Classifier))
+        .foldLeft(defn.AnyClass)(leastClassifier)
+    else defn.AnyClass
+
 extension (sym: Symbol)
 
   /** This symbol is one of `retains` or `retainsCap` */
@@ -630,28 +664,6 @@ object FunctionOrMethod:
     case defn.RefinedFunctionOf(rinfo) => unapply(rinfo)
     case _ => None
 
-/** If `tp` is a function or method, a type of the same kind with the given
- *  argument and result types.
- */
-extension (self: Type)
-  def derivedFunctionOrMethod(argTypes: List[Type], resType: Type)(using Context): Type = self match
-    case self @ AppliedType(tycon, args) if defn.isNonRefinedFunction(self) =>
-      val args1 = argTypes :+ resType
-      if args.corresponds(args1)(_ eq _) then self
-      else self.derivedAppliedType(tycon, args1)
-    case self @ defn.RefinedFunctionOf(rinfo) =>
-      val rinfo1 = rinfo.derivedFunctionOrMethod(argTypes, resType)
-      if rinfo1 eq rinfo then self
-      else if rinfo1.isInstanceOf[PolyType] then self.derivedRefinedType(refinedInfo = rinfo1)
-      else rinfo1.toFunctionType(alwaysDependent = true)
-    case self: MethodType =>
-      self.derivedLambdaType(paramInfos = argTypes, resType = resType)
-    case self: PolyType =>
-      assert(argTypes.isEmpty)
-      self.derivedLambdaType(resType = resType)
-    case _ =>
-      self
-
 /** An extractor for a contains argument */
 object ContainsImpl:
   def unapply(tree: TypeApply)(using Context): Option[(Tree, Tree)] =

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

@@ -410,6 +410,20 @@ sealed abstract class CaptureSet extends Showable:
     if mutability != Ignored then res.mutability = Reader
     res
 
+  def transClassifiers(using Context): Classifiers =
+    if isConst then
+      (ClassifiedAs(Nil) /: elems.map(_.transClassifiers))(joinClassifiers)
+    else UnknownClassifier
+
+  def tryClassifyAs(cls: ClassSymbol)(using Context): Boolean =
+    elems.forall(_.tryClassifyAs(cls))
+
+  def adoptClassifier(cls: ClassSymbol)(using Context): Unit =
+    for elem <- elems do
+      elem.stripReadOnly match
+        case fresh: FreshCap => fresh.hiddenSet.adoptClassifier(cls)
+        case _ =>
+
   /** A bad root `elem` is inadmissible as a member of this set. What is a bad roots depends
    *  on the value of `rootLimit`.
    *  If the limit is null, all capture roots are good.
@@ -651,6 +665,25 @@ object CaptureSet:
      */
     private[CaptureSet] var rootLimit: Symbol | Null = null
 
+    private var myClassifier: ClassSymbol = defn.AnyClass
+    def classifier: ClassSymbol = myClassifier
+
+    private def narrowClassifier(cls: ClassSymbol)(using Context): Unit =
+      val newClassifier = leastClassifier(classifier, cls)
+      if newClassifier == defn.NothingClass then
+        println(i"conflicting classifications for $this, was $classifier, now $cls")
+      myClassifier = newClassifier
+
+    override def adoptClassifier(cls: ClassSymbol)(using Context): Unit =
+      if !classifier.isSubClass(cls) then // serves as recursion brake
+        narrowClassifier(cls)
+        super.adoptClassifier(cls)
+
+    override def tryClassifyAs(cls: ClassSymbol)(using Context): Boolean =
+      classifier.isSubClass(cls)
+      || super.tryClassifyAs(cls)
+          && { narrowClassifier(cls); true }
+
     /** A handler to be invoked when new elems are added to this set */
     var newElemAddedHandler: Capability => Context ?=> Unit = _ => ()
 
@@ -682,14 +715,15 @@ object CaptureSet:
         addIfHiddenOrFail(elem)
       else if !levelOK(elem) then
         failWith(IncludeFailure(this, elem, levelError = true))    // or `elem` is not visible at the level of the set.
+      else if !elem.tryClassifyAs(classifier) then
+        failWith(IncludeFailure(this, elem))
       else
         // id == 108 then assert(false, i"trying to add $elem to $this")
         assert(elem.isWellformed, elem)
         assert(!this.isInstanceOf[HiddenSet] || summon[VarState].isSeparating, summon[VarState])
         includeElem(elem)
         if isBadRoot(rootLimit, elem) then
           rootAddedHandler()
-        newElemAddedHandler(elem)
         val normElem = if isMaybeSet then elem else elem.stripMaybe
         // assert(id != 5 || elems.size != 3, this)
         val res = deps.forall: dep =>

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

@@ -40,6 +40,8 @@ object CapturingType:
         apply(parent1, refs ++ refs1, boxed)
       case _ =>
         if parent.derivesFromMutable then refs.setMutable()
+        val classifier = parent.classifier
+        refs.adoptClassifier(parent.classifier)
         AnnotatedType(parent, CaptureAnnotation(refs, boxed)(defn.RetainsAnnot))
 
   /** An extractor for CapturingTypes. Capturing types are recognized if

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

@@ -114,6 +114,11 @@ object CheckCaptures:
       case ReadOnlyCapability(ref) =>
         check(ref)
       case OnlyCapability(ref, cls) =>
+        if !cls.isClassifiedCapabilityClass then
+          report.error(
+            em"""${ref.showRef}.only[${cls.name}] is not well-formed since $cls is not a classifier class.
+                |A classifier class is a class extending `caps.Capability` and directly extending `caps.Classifier`.""",
+            ann.srcPos)
         check(ref)
       case tpe =>
         report.error(em"$elem: $tpe is not a legal element of a capture set", ann.srcPos)

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

@@ -598,7 +598,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
    *   - If the reference is to a this type of the enclosing class, the
    *     access must be in a @consume method.
    *
-   *  References that extend cpas.Sharable are excluded from checking.
+   *  References that extend caps.Sharable are excluded from checking.
    *  As a side effect, add all checked references with the given position `pos`
    *  to the global `consumed` map.
    *
@@ -612,7 +612,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
     val badParams = mutable.ListBuffer[Symbol]()
     def currentOwner = role.dclSym.orElse(ctx.owner)
     for hiddenRef <- refsToCheck.deductSymRefs(role.dclSym).deduct(explicitRefs(tpe)) do
-      if !hiddenRef.derivesFromSharedCapability then
+      if !hiddenRef.derivesFromSharable then
         hiddenRef.pathRoot match
           case ref: TermRef =>
             val refSym = ref.symbol
@@ -649,7 +649,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
     role match
       case _: TypeRole.Argument | _: TypeRole.Qualifier =>
         for ref <- refsToCheck do
-          if !ref.derivesFromSharedCapability then
+          if !ref.derivesFromSharable then
             consumed.put(ref, pos)
       case _ =>
   end checkConsumedRefs