Always use the sealed policy

Drop the exception that held only in 3.5

Author: odersky

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

@@ -43,15 +43,6 @@ object ccConfig:
    */
   inline val deferredReaches = false
 
-  /** If true, use "sealed" as encapsulation mechanism, meaning that we
-   *  check that type variable instantiations don't have `cap` in any of
-   *  their capture sets. This is an alternative of the original restriction
-   *  that `cap` can't be boxed or unboxed. It is dropped in 3.5 but used
-   *  again in 3.6.
-   */
-  def useSealed(using Context) =
-    Feature.sourceVersion.stable != SourceVersion.`3.5`
-
   /** If true, turn on separation checking */
   def useSepChecks(using Context): Boolean =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)

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

@@ -215,42 +215,9 @@ object CheckCaptures:
             finally openExistentialScopes = saved
           case t =>
             traverseChildren(t)
-    if ccConfig.useSealed then check.traverse(tp)
+    check.traverse(tp)
   end disallowRootCapabilitiesIn
 
-  /** If we are not under the sealed policy, and a tree is an application that unboxes
-   *  its result or is a try, check that the tree's type does not have covariant universal
-   *  capabilities.
-   */
-  private def checkNotUniversalInUnboxedResult(tpe: Type, tree: Tree)(using Context): Unit =
-    def needsUniversalCheck = tree match
-      case _: RefTree | _: Apply | _: TypeApply => tree.symbol.unboxesResult
-      case _: Try => true
-      case _ => false
-
-    object checkNotUniversal extends TypeTraverser:
-      def traverse(tp: Type) =
-        tp.dealias match
-        case wtp @ CapturingType(parent, refs) =>
-          if variance > 0 then
-            refs.disallowRootCapability: () =>
-              def part = if wtp eq tpe.widen then "" else i" in its part $wtp"
-              report.error(
-                em"""The expression's type ${tpe.widen} is not allowed to capture the root capability `cap`$part.
-                  |This usually means that a capability persists longer than its allowed lifetime.""",
-                tree.srcPos)
-          if !wtp.isBoxed then traverse(parent)
-        case tp =>
-          traverseChildren(tp)
-
-    if !ccConfig.useSealed
-        && !tpe.hasAnnotation(defn.UncheckedCapturesAnnot)
-        && needsUniversalCheck
-        && tpe.widen.isValueType
-    then
-      checkNotUniversal.traverse(tpe.widen)
-  end checkNotUniversalInUnboxedResult
-
   trait CheckerAPI:
     /** Complete symbol info of a val or a def */
     def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type
@@ -584,7 +551,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree])(using Context): Unit =
       def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
-      if ccConfig.useSealed && !isExempt then
+      if !isExempt then
         val paramNames = atPhase(thisPhase.prev):
           fn.tpe.widenDealias match
             case tl: TypeLambda => tl.paramNames
@@ -1178,7 +1145,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     override def recheckTry(tree: Try, pt: Type)(using Context): Type =
       val tp = super.recheckTry(tree, pt)
-      if ccConfig.useSealed && Feature.enabled(Feature.saferExceptions) then
+      if Feature.enabled(Feature.saferExceptions) then
         disallowRootCapabilitiesIn(tp, ctx.owner,
           "The result of `try`", "have type",
           "\nThis is often caused by a locally generated exception capability leaking as part of its result.",
@@ -1227,12 +1194,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       res
     end recheck
 
-    /** Under the old unsealed policy: check that cap is ot unboxed */
-    override def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
-      checkNotUniversalInUnboxedResult(tpe, tree)
-      super.recheckFinish(tpe, tree, pt)
-    end recheckFinish
-
     // ------------------ Adaptation -------------------------------------
     //
     // Adaptations before checking conformance of actual vs expected:
@@ -1487,34 +1448,12 @@ class CheckCaptures extends Recheck, SymTransformer:
             .capturing(if alwaysConst then CaptureSet(captures.elems) else captures)
             .forceBoxStatus(resultBoxed)
 
-        if needsAdaptation then
-          val criticalSet =          // the set with which we box or unbox
+        if needsAdaptation && !insertBox then // we are unboxing
+          val criticalSet =          // the set with which we unbox
             if covariant then captures   // covariant: we box with captures of actual type plus captures leaked by inner adapation
             else expected.captureSet     // contravarant: we unbox with captures of epected type
-          def msg = em"""$actual cannot be box-converted to $expected
-                        |since at least one of their capture sets contains the root capability `cap`"""
-          def allowUniversalInBoxed =
-            ccConfig.useSealed
-            || expected.hasAnnotation(defn.UncheckedCapturesAnnot)
-            || actual.widen.hasAnnotation(defn.UncheckedCapturesAnnot)
-          if !allowUniversalInBoxed then
-            if criticalSet.isUnboxable && expected.isValueType then
-              // We can't box/unbox the universal capability. Leave `actual` as it is
-              // so we get an error in checkConforms. Add the error message generated
-              // from boxing as an addendum. This tends to give better error
-              // messages than disallowing the root capability in `criticalSet`.
-              if boxErrors != null then boxErrors += msg
-              if ctx.settings.YccDebug.value then
-                println(i"cannot box/unbox $actual vs $expected")
-              return actual
-            // Disallow future addition of `cap` to `criticalSet`.
-            criticalSet.disallowRootCapability: () =>
-              report.error(msg, tree.srcPos)
-
-          if !insertBox then  // we are unboxing
             //debugShowEnvs()
-            markFree(criticalSet, tree)
-        end if
+          markFree(criticalSet, tree)
 
         // Compute the adapted type.
         // The result is boxed if actual is boxed and we don't need to adapt,
@@ -1901,8 +1840,6 @@ class CheckCaptures extends Recheck, SymTransformer:
                 checkBounds(normArgs, tl)
                 args.lazyZip(tl.paramNames).foreach(healTypeParam(_, _, fun.symbol))
               case _ =>
-          case tree: TypeTree if !ccConfig.useSealed =>
-            checkArraysAreSealedIn(tree.tpe, tree.srcPos)
           case _ =>
         end check
       end checker

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

@@ -553,14 +553,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     def transformResultType(tpt: TypeTree, sym: Symbol)(using Context): Unit =
       // First step: Transform the type and record it as knownType of tpt.
       try
-        transformTT(tpt, sym,
-            boxed =
-              sym.isMutableVar
-                && !ccConfig.useSealed
-                && !sym.hasAnnotation(defn.UncheckedCapturesAnnot),
-              // Under the sealed policy, we disallow root capabilities in the type of mutable
-              // variables, no need to box them here.
-          )
+        transformTT(tpt, sym, boxed = false)
       catch case ex: IllegalCaptureRef =>
         capt.println(i"fail while transforming result type $tpt of $sym")
         throw ex