Integrate root.scala in Capability.scala

Author: odersky

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

@@ -164,7 +164,7 @@ object CCState:
   /** Is `caps.cap` a root capability that is allowed to subsume other capabilities? */
   def capIsRoot(using Context): Boolean = ccState.capIsRoot
 
-  /** Run `op` under the assumption that all root.Fresh instances are equal.
+  /** Run `op` under the assumption that all FreshCap instances are equal.
    *  Needed to make override checking of types containing fresh work.
    *  Asserted in override checking, tested in maxSubsumes.
    *  Is this sound? Test case is neg-custom-args/captures/leaked-curried.scala.
@@ -177,7 +177,7 @@ object CCState:
       try op finally ccs.ignoreFreshLevels = saved
     else op
 
-  /** Should all root.Fresh instances be treated equal? */
+  /** Should all FreshCap instances be treated equal? */
   def ignoreFreshLevels(using Context): Boolean = ccState.ignoreFreshLevels
 
 end CCState

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

@@ -4,7 +4,7 @@ package cc
 
 import core.*
 import Types.*, Symbols.*, Contexts.*, Decorators.*
-import util.{SimpleIdentitySet, Property}
+import util.{SimpleIdentitySet, EqHashMap}
 import typer.ErrorReporting.Addenda
 import util.common.alwaysTrue
 import scala.collection.mutable
@@ -21,9 +21,14 @@ import annotation.constructorOnly
 import ast.tpd
 import printing.{Printer, Showable}
 import printing.Texts.Text
+import reporting.Message
+import NameOps.isImpureFunction
 import annotation.internal.sharable
 
-/** Capability --+-- RootCapabilty -----+-- GlobalCap
+/** Capabilities are members of capture sets. They partially overlap with types
+ *  as shown in the trait hierarchy below.
+ *
+ *  Capability --+-- RootCapabilty -----+-- GlobalCap
  *               |                      +-- FreshCap
  *               |                      +-- ResultCap
  *               |
@@ -47,7 +52,7 @@ object Capabilities:
   def currentId(using Context): Validity = validId(ctx.runId, ccState.iterationId)
   val invalid: Validity = validId(NoRunId, 0)
 
-  @sharable var nextRootId = 0
+  @sharable private var nextRootId = 0
 
   /** The base trait of all root capabilities */
   trait RootCapability extends Capability:
@@ -130,8 +135,7 @@ object Capabilities:
    *  @param origin  an indication where and why the FreshCap was created, used
    *                 for diagnostics
    */
-  case class FreshCap private (owner: Symbol, origin: root.Origin)(using @constructorOnly ctx: Context)
-  extends RootCapability:
+  case class FreshCap private (owner: Symbol, origin: Origin)(using @constructorOnly ctx: Context) extends RootCapability:
     val hiddenSet = CaptureSet.HiddenSet(owner)
     hiddenSet.owningCap = this
 
@@ -140,10 +144,38 @@ object Capabilities:
       case _ => false
 
   object FreshCap:
-    def apply(origin: root.Origin)(using Context): FreshCap | GlobalCap.type =
+    def apply(origin: Origin)(using Context): FreshCap | GlobalCap.type =
       if ccConfig.useSepChecks then FreshCap(ctx.owner, origin)
       else GlobalCap
 
+  /** A root capability associated with a function type. These are conceptually
+   *  existentially quantified over the function's result type.
+   *  @param  binder  The function type with which the capability is associated.
+   *                  It is a MethodicType since we also have ResultCaps that are
+   *                  associated with the ExprTypes of parameterless functions.
+   *                  Currently we never create results over PolyTypes. TODO change this?
+   * Setup:
+   *
+   *  In the setup phase, `cap` instances in the result of a dependent function type
+   *  or method type such as `(x: T): C^{cap}` are converted to `ResultCap(binder)` instances,
+   *  where `binder` refers to the method type. Most other cap instances are mapped to
+   *  Fresh instances instead. For example the `cap` in the result of `T => C^{cap}`
+   *  is mapped to a Fresh instance.
+   *
+   *  If one needs to use a dependent function type yet one still want to map `cap` to
+   *  a fresh instance instead an existential root, one can achieve that by the use
+   *  of a type alias. For instance, the following type creates an existential for `^`:
+   *
+   *       (x: A) => (C^{x}, D^)
+   *
+   *  By contrast, this variant creates a fresh instance instead:
+   *
+   *       type F[X] = (x: A) => (C^{x}, X)
+   *       F[D^]
+   *
+   *  The trick is that the argument D^ is mapped to D^{fresh} before the `F` alias
+   *  is expanded.
+   */
   case class ResultCap(binder: MethodicType) extends RootCapability:
     private var myOriginalBinder = binder
     def originalBinder: MethodicType = myOriginalBinder
@@ -283,7 +315,7 @@ object Capabilities:
     *   - If it starts with a reference `r`, `r`'s owner.
     *   - If it starts with cap, the `scala.caps` package class.
     *   - If it starts with a fresh instance, its owner.
-    *   - If it starts with a ParamRef or a result root, NoSymbol.
+    *   - If it starts with a ParamRef or a ResultCap, NoSymbol.
     */
     final def pathOwner(using Context): Symbol = pathRoot match
       case tp1: ThisType => tp1.cls
@@ -521,4 +553,259 @@ object Capabilities:
 
     def toText(printer: Printer): Text = printer.toTextCapability(this)
   end Capability
+
+  /** The place of - and cause for - creating a fresh capability. Used for
+   *  error diagnostics
+   */
+  enum Origin:
+    case InDecl(sym: Symbol)
+    case TypeArg(tp: Type)
+    case UnsafeAssumePure
+    case Formal(pref: ParamRef, app: tpd.Apply)
+    case ResultInstance(methType: Type, meth: Symbol)
+    case UnapplyInstance(info: MethodType)
+    case NewMutable(tp: Type)
+    case NewCapability(tp: Type)
+    case LambdaExpected(respt: Type)
+    case LambdaActual(restp: Type)
+    case OverriddenType(member: Symbol)
+    case DeepCS(ref: TypeRef)
+    case Unknown
+
+    def explanation(using Context): String = this match
+      case InDecl(sym: Symbol) =>
+        if sym.is(Method) then i" in the result type of $sym"
+        else if sym.exists then i" in the type of $sym"
+        else ""
+      case TypeArg(tp: Type) =>
+        i" of type argument $tp"
+      case UnsafeAssumePure =>
+        " when instantiating argument of unsafeAssumePure"
+      case Formal(pref, app) =>
+        val meth = app.symbol
+        if meth.exists
+        then i" when checking argument to parameter ${pref.paramName} of $meth"
+        else ""
+      case ResultInstance(mt, meth) =>
+        val methDescr = if meth.exists then i"$meth's type " else ""
+        i" when instantiating $methDescr$mt"
+      case UnapplyInstance(info) =>
+        i" when instantiating argument of unapply with type $info"
+      case NewMutable(tp) =>
+        i" when constructing mutable $tp"
+      case NewCapability(tp) =>
+        i" when constructing Capability instance $tp"
+      case LambdaExpected(respt) =>
+        i" when instantiating expected result type $respt of lambda"
+      case LambdaActual(restp: Type) =>
+        i" when instantiating result type $restp of lambda"
+      case OverriddenType(member: Symbol) =>
+        i" when instantiating upper bound of member overridden by $member"
+      case DeepCS(ref: TypeRef) =>
+        i" when computing deep capture set of $ref"
+      case Unknown =>
+        ""
+  end Origin
+
+  // ---------- Maps between different kinds of root capabilities -----------------
+
+
+  /** Map each occurrence of cap to a different Fresh instance
+   *  Exception: CapSet^ stays as it is.
+   */
+  class CapToFresh(origin: Origin)(using Context) extends BiTypeMap, FollowAliasesMap:
+    thisMap =>
+
+    override def apply(t: Type) =
+      if variance <= 0 then t
+      else t match
+        case t @ CapturingType(parent: TypeRef, _) if parent.symbol == defn.Caps_CapSet =>
+          t
+        case t @ CapturingType(_, _) =>
+          mapOver(t)
+        case t @ AnnotatedType(parent, ann) =>
+          val parent1 = this(parent)
+          if ann.symbol.isRetains && ann.tree.toCaptureSet.containsCap then
+            this(CapturingType(parent1, ann.tree.toCaptureSet))
+          else
+            t.derivedAnnotatedType(parent1, ann)
+        case _ =>
+          mapFollowingAliases(t)
+
+    override def mapCapability(c: Capability, deep: Boolean): Capability = c match
+      case GlobalCap => FreshCap(origin)
+      case _ => super.mapCapability(c, deep)
+
+    override def fuse(next: BiTypeMap)(using Context) = next match
+      case next: Inverse => assert(false); Some(IdentityTypeMap)
+      case _ => None
+
+    override def toString = "CapToFresh"
+
+    class Inverse extends BiTypeMap, FollowAliasesMap:
+      def apply(t: Type): Type = t match
+        case t @ CapturingType(_, refs) => mapOver(t)
+        case _ => mapFollowingAliases(t)
+
+      override def mapCapability(c: Capability, deep: Boolean): Capability = c match
+        case _: FreshCap => GlobalCap
+        case _ => super.mapCapability(c, deep)
+
+      def inverse = thisMap
+      override def toString = thisMap.toString + ".inverse"
+
+    lazy val inverse = Inverse()
+
+  end CapToFresh
+
+  /** Maps cap to fresh. CapToFresh is a BiTypeMap since we don't want to
+   *  freeze a set when it is mapped. On the other hand, we do not want Fresh
+   *  values to flow back to cap since that would fail disallowRootCapability
+   *  tests elsewhere. We therefore use `withoutMappedFutureElems` to prevent
+   *  the map being installed for future use.
+   */
+  def capToFresh(tp: Type, origin: Origin)(using Context): Type =
+    if ccConfig.useSepChecks then
+      ccState.withoutMappedFutureElems:
+        CapToFresh(origin)(tp)
+    else tp
+
+  /** Maps fresh to cap */
+  def freshToCap(tp: Type)(using Context): Type =
+    if ccConfig.useSepChecks then CapToFresh(Origin.Unknown).inverse(tp) else tp
+
+  /** Map top-level free existential variables one-to-one to Fresh instances */
+  def resultToFresh(tp: Type, origin: Origin)(using Context): Type =
+    val subst = new TypeMap:
+      val seen = EqHashMap[ResultCap, FreshCap | GlobalCap.type]()
+      var localBinders: SimpleIdentitySet[MethodType] = SimpleIdentitySet.empty
+
+      def apply(t: Type): Type = t match
+        case t: MethodType =>
+          // skip parameters
+          val saved = localBinders
+          if t.marksExistentialScope then localBinders = localBinders + t
+          try t.derivedLambdaType(resType = this(t.resType))
+          finally localBinders = saved
+        case t: PolyType =>
+          // skip parameters
+          t.derivedLambdaType(resType = this(t.resType))
+        case _ =>
+          mapOver(t)
+
+      override def mapCapability(c: Capability, deep: Boolean) = c match
+        case c @ ResultCap(binder) =>
+          if localBinders.contains(binder) then c // keep bound references
+          else seen.getOrElseUpdate(c, FreshCap(origin)) // map free references to FreshCap
+        case _ => super.mapCapability(c, deep)
+    end subst
+
+    subst(tp)
+  end resultToFresh
+
+  /** Replace all occurrences of `cap` (or fresh) in parts of this type by an existentially bound
+   *  variable bound by `mt`.
+   *  Stop at function or method types since these have been mapped before.
+   */
+  def toResult(tp: Type, mt: MethodicType, fail: Message => Unit)(using Context): Type =
+
+    abstract class CapMap extends BiTypeMap:
+      override def mapOver(t: Type): Type = t match
+        case t @ FunctionOrMethod(args, res) if variance > 0 && !t.isAliasFun =>
+          t // `t` should be mapped in this case by a different call to `mapCap`.
+        case t: (LazyRef | TypeVar) =>
+          mapConserveSuper(t)
+        case _ =>
+          super.mapOver(t)
+
+    object toVar extends CapMap:
+      private val seen = EqHashMap[RootCapability, ResultCap]()
+
+      def apply(t: Type) = t match
+        case defn.FunctionNOf(args, res, contextual) if t.typeSymbol.name.isImpureFunction =>
+          if variance > 0 then
+            super.mapOver:
+              defn.FunctionNOf(args, res, contextual)
+                .capturing(ResultCap(mt).singletonCaptureSet)
+          else mapOver(t)
+        case _ =>
+          mapOver(t)
+
+      override def mapCapability(c: Capability, deep: Boolean) = c match
+        case c: (FreshCap | GlobalCap.type) =>
+          if variance > 0 then
+            seen.getOrElseUpdate(c, ResultCap(mt))
+          else
+            if variance == 0 then
+              fail(em"""$tp captures the root capability `cap` in invariant position.
+                       |This capability cannot be converted to an existential in the result type of a function.""")
+            // we accept variance < 0, and leave the cap as it is
+            c
+        case _ =>
+          super.mapCapability(c, deep)
+
+        //.showing(i"mapcap $t = $result")
+      override def toString = "toVar"
+
+      object inverse extends BiTypeMap:
+        def apply(t: Type) = mapOver(t)
+
+        override def mapCapability(c: Capability, deep: Boolean) = c match
+          case c @ ResultCap(`mt`) =>
+            // do a reverse getOrElseUpdate on `seen` to produce the
+            // `Fresh` assosicated with `t`
+            val it = seen.iterator
+            var ref: RootCapability | Null = null
+            while it.hasNext && ref == null do
+              val (k, v) = it.next
+              if v eq c then ref = k
+            if ref == null then
+              ref = FreshCap(Origin.Unknown)
+              seen(ref) = c
+            ref
+          case _ =>
+            super.mapCapability(c, deep)
+
+        def inverse = toVar.this
+        override def toString = "toVar.inverse"
+      end inverse
+    end toVar
+
+    toVar(tp)
+  end toResult
+
+  /** Map global roots in function results to result roots. Also,
+   *  map roots in the types of parameterless def methods.
+   */
+  def toResultInResults(sym: Symbol, fail: Message => Unit, keepAliases: Boolean = false)(tp: Type)(using Context): Type =
+    val m = new TypeMap with FollowAliasesMap:
+      def apply(t: Type): Type = t match
+        case AnnotatedType(parent @ defn.RefinedFunctionOf(mt), ann) if ann.symbol == defn.InferredDepFunAnnot =>
+          val mt1 = mapOver(mt).asInstanceOf[MethodType]
+          if mt1 ne mt then mt1.toFunctionType(alwaysDependent = true)
+          else parent
+        case defn.RefinedFunctionOf(mt) =>
+          val mt1 = apply(mt)
+          if mt1 ne mt then mt1.toFunctionType(alwaysDependent = true)
+          else t
+        case t: MethodType if variance > 0 && t.marksExistentialScope =>
+          val t1 = mapOver(t).asInstanceOf[MethodType]
+          t1.derivedLambdaType(resType = toResult(t1.resType, t1, fail))
+        case CapturingType(parent, refs) =>
+          t.derivedCapturingType(this(parent), refs)
+        case t: (LazyRef | TypeVar) =>
+          mapConserveSuper(t)
+        case _ =>
+          try
+            if keepAliases then mapOver(t)
+            else mapFollowingAliases(t)
+          catch case ex: AssertionError =>
+            println(i"error while mapping $t")
+            throw ex
+    m(tp) match
+      case tp1: ExprType if sym.is(Method, butNot = Accessor) =>
+        tp1.derivedExprType(toResult(tp1.resType, tp1, fail))
+      case tp1 => tp1
+  end toResultInResults
+
 end Capabilities

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

@@ -120,7 +120,7 @@ extension (tp: Type)
       false
 
   /** The capture set of a type. This is:
-    *   - For trackable capabilities: The singleton capture set consisting of
+    *   - For object capabilities: The singleton capture set consisting of
     *     just the reference, provided the underlying capture set of their info is not empty.
     *   - For other capabilities: The capture set of their info
     *   - For all other types: The result of CaptureSet.ofType
@@ -370,7 +370,7 @@ extension (tp: Type)
                 // preceding arguments are known to be always pure
                 t.derivedFunctionOrMethod(
                   args,
-                  apply(root.resultToFresh(res, root.Origin.ResultInstance(t, NoSymbol))))
+                  apply(resultToFresh(res, Origin.ResultInstance(t, NoSymbol))))
               else
                 t
             case _ =>
@@ -654,7 +654,7 @@ abstract class DeepTypeAccumulator[T](using Context) extends TypeAccumulator[T]:
         this(acc, parent)
       case t @ FunctionOrMethod(args, res) =>
         if args.forall(_.isAlwaysPure) then
-          this(acc, root.resultToFresh(res, root.Origin.ResultInstance(t, NoSymbol)))
+          this(acc, resultToFresh(res, Origin.ResultInstance(t, NoSymbol)))
         else acc
       case _ =>
         foldOver(acc, t)