Revert "Implement sealed type variables"

This reverts commit 05bce38.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
#	compiler/src/dotty/tools/dotc/cc/Setup.scala
#	library/src/scala/caps.scala
#	tests/neg-custom-args/captures/capt-test.scala
#	tests/neg-custom-args/captures/capt1.check
#	tests/neg-custom-args/captures/ctest.scala
#	tests/neg-custom-args/captures/filevar.scala
#	tests/neg-custom-args/captures/heal-tparam-cs.scala
#	tests/neg-custom-args/captures/i15049.scala
#	tests/neg-custom-args/captures/i15772.check
#	tests/neg-custom-args/captures/i15923.scala
#	tests/neg-custom-args/captures/lazylists-exceptions.check
#	tests/neg-custom-args/captures/real-try.check
#	tests/neg-custom-args/captures/real-try.scala
#	tests/neg-custom-args/captures/sealed-leaks.scala
#	tests/neg-custom-args/captures/stack-alloc.scala
#	tests/neg-custom-args/captures/try.check
#	tests/neg-custom-args/captures/try.scala
#	tests/neg-custom-args/captures/try3.scala
#	tests/neg-custom-args/captures/usingLogFile.check
#	tests/neg-custom-args/captures/usingLogFile.scala
#	tests/neg-custom-args/captures/vars.check
#	tests/neg-custom-args/captures/vars.scala
#	tests/pos-custom-args/captures/vars1.scala

Author: odersky

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

@@ -173,21 +173,6 @@ object CheckCaptures:
         val srcTree = if ann.span.exists then ann else tpt
         report.warning(em"redundant capture: $remaining already accounts for $ref", srcTree.srcPos)
 
-  /** Report an error if some part of `tp` contains the root capability in its capture set */
-  def disallowRootCapabilitiesIn(tp: Type, what: String, have: String, addendum: String, pos: SrcPos)(using Context) =
-    val check = new TypeTraverser:
-      def traverse(t: Type) =
-        if variance >= 0 then
-          t.captureSet.disallowRootCapability: () =>
-            def part = if t eq tp then "" else i"the part $t of "
-            report.error(
-              em"""$what cannot $have $tp since
-                  |${part}that type captures the root capability `cap`.
-                  |$addendum""",
-              pos)
-        traverseChildren(t)
-    check.traverse(tp)
-
   /** Attachment key for bodies of closures, provided they are values */
   val ClosureBodyValue = Property.Key[Unit]
 
@@ -693,17 +678,11 @@ class CheckCaptures extends Recheck, SymTransformer:
       val tryOwner = ccState.tryBlockOwner.remove(tree).getOrElse(ctx.owner)
       val saved = curEnv
       curEnv = Env(tryOwner, EnvKind.Regular, CaptureSet.Var(curEnv.owner), curEnv)
-      val tp = try
+      try
         inContext(ctx.withOwner(tryOwner)):
           super.recheckTry(tree, pt)
         finally
           curEnv = saved
-      if allowUniversalInBoxed && Feature.enabled(Feature.saferExceptions) then
-        disallowRootCapabilitiesIn(tp,
-          "Result of `try`", "have type",
-          "This is often caused by a locally generated exception capability leaking as part of its result.",
-          tree.srcPos)
-      tp
 
     /* Currently not needed, since capture checking takes place after ElimByName.
      * Keep around in case we need to get back to it

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

@@ -356,29 +356,11 @@ extends tpd.TreeTraverser:
           mapRoots
         )
         capt.println(i"mapped $tree = ${tpt.knownType}")
-        if allowUniversalInBoxed && tree.symbol.is(Mutable)
-            && !tree.symbol.hasAnnotation(defn.UncheckedCapturesAnnot)
-        then
-          CheckCaptures.disallowRootCapabilitiesIn(tpt.knownType,
-            i"Mutable variable ${tree.symbol.name}", "have type",
-            "This restriction serves to prevent local capabilities from escaping the scope where they are defined.",
-            tree.srcPos)
         traverse(tree.rhs)
       case tree @ TypeApply(fn, args) =>
         traverse(fn)
         for case arg: TypeTree <- args do
           transformTT(arg, boxed = true, exact = false, mapRoots = true) // type arguments in type applications are boxed
-
-        if allowUniversalInBoxed then
-          val polyType = atPhase(preRecheckPhase):
-            fn.tpe.widen.asInstanceOf[TypeLambda]
-          for case (arg: TypeTree, pinfo, pname) <- args.lazyZip(polyType.paramInfos).lazyZip((polyType.paramNames)) do
-            if pinfo.bounds.hi.hasAnnotation(defn.Caps_SealedAnnot) then
-              def where = if fn.symbol.exists then i" in an argument of ${fn.symbol}" else ""
-              CheckCaptures.disallowRootCapabilitiesIn(arg.knownType,
-                i"Sealed type variable $pname", "be instantiated to",
-                i"This is often caused by a local capability$where\nleaking as part of its result.",
-                tree.srcPos)
       case tree: Template =>
         inContext(ctx.withOwner(tree.symbol.owner)):
           traverseChildren(tree)

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -977,7 +977,6 @@ class Definitions {
     @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
     @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")
     @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")
-    @tu lazy val Caps_SealedAnnot: ClassSymbol = requiredClass("scala.caps.Sealed")
 
   @tu lazy val PureClass: Symbol = requiredClass("scala.Pure")
 
@@ -1028,7 +1027,6 @@ class Definitions {
   @tu lazy val UncheckedAnnot: ClassSymbol = requiredClass("scala.unchecked")
   @tu lazy val UncheckedStableAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
   @tu lazy val UncheckedVarianceAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedVariance")
-  @tu lazy val UncheckedCapturesAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedCaptures")
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val WithPureFunsAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WithPureFuns")
   @tu lazy val CaptureCheckedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.CaptureChecked")

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -4082,15 +4082,10 @@ object Types {
 
     protected def toPInfo(tp: Type)(using Context): PInfo
 
-    /** If `tparam` is a sealed type parameter symbol of a polymorphic method, add
-     *  a @caps.Sealed annotation to the upperbound in `tp`.
-     */
-    protected def addSealed(tparam: ParamInfo, tp: Type)(using Context): Type = tp
-
     def fromParams[PI <: ParamInfo.Of[N]](params: List[PI], resultType: Type)(using Context): Type =
       if (params.isEmpty) resultType
       else apply(params.map(_.paramName))(
-        tl => params.map(param => toPInfo(addSealed(param, tl.integrate(params, param.paramInfo)))),
+        tl => params.map(param => toPInfo(tl.integrate(params, param.paramInfo))),
         tl => tl.integrate(params, resultType))
   }
 
@@ -4412,16 +4407,6 @@ object Types {
         resultTypeExp: PolyType => Type)(using Context): PolyType =
       unique(new PolyType(paramNames)(paramInfosExp, resultTypeExp))
 
-    override protected def addSealed(tparam: ParamInfo, tp: Type)(using Context): Type =
-      tparam match
-        case tparam: Symbol if tparam.is(Sealed) =>
-          tp match
-            case tp @ TypeBounds(lo, hi) =>
-              tp.derivedTypeBounds(lo,
-                AnnotatedType(hi, Annotation(defn.Caps_SealedAnnot, tparam.span)))
-            case _ => tp
-        case _ => tp
-
     def unapply(tl: PolyType): Some[(List[LambdaParam], Type)] =
       Some((tl.typeParams, tl.resType))
   }

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3179,9 +3179,7 @@ object Parsers {
      *                         id [HkTypeParamClause] TypeParamBounds
      *
      *  DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-     *  DefTypeParam      ::=  {Annotation}
-     *                         [`sealed`]                                    -- under captureChecking
-     *                         id [HkTypeParamClause] TypeParamBounds
+     *  DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
      *
      *  TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
      *  TypTypeParam      ::=  {Annotation} id [HkTypePamClause] TypeBounds
@@ -3191,25 +3189,24 @@ object Parsers {
      */
     def typeParamClause(ownerKind: ParamOwner): List[TypeDef] = inBrackets {
 
-      def checkVarianceOK(): Boolean =
-        val ok = ownerKind != ParamOwner.Def && ownerKind != ParamOwner.TypeParam
-        if !ok then syntaxError(em"no `+/-` variance annotation allowed here")
-        in.nextToken()
-        ok
+      def variance(vflag: FlagSet): FlagSet =
+        if ownerKind == ParamOwner.Def || ownerKind == ParamOwner.TypeParam then
+          syntaxError(em"no `+/-` variance annotation allowed here")
+          in.nextToken()
+          EmptyFlags
+        else
+          in.nextToken()
+          vflag
 
       def typeParam(): TypeDef = {
         val isAbstractOwner = ownerKind == ParamOwner.Type || ownerKind == ParamOwner.TypeParam
         val start = in.offset
-        var mods = annotsAsMods() | Param
-        if ownerKind == ParamOwner.Class then mods |= PrivateLocal
-        if Feature.ccEnabled && in.token == SEALED then
-          if ownerKind == ParamOwner.Def then mods |= Sealed
-          else syntaxError(em"`sealed` modifier only allowed for method type parameters")
-          in.nextToken()
-        if isIdent(nme.raw.PLUS) && checkVarianceOK() then
-          mods |= Covariant
-        else if isIdent(nme.raw.MINUS) && checkVarianceOK() then
-          mods |= Contravariant
+        val mods =
+          annotsAsMods()
+          | (if (ownerKind == ParamOwner.Class) Param | PrivateLocal else Param)
+          | (if isIdent(nme.raw.PLUS) then variance(Covariant)
+             else if isIdent(nme.raw.MINUS) then variance(Contravariant)
+             else EmptyFlags)
         atSpan(start, nameStart) {
           val name =
             if (isAbstractOwner && in.token == USCORE) {

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -517,12 +517,7 @@ object Checking {
         // note: this is not covered by the next test since terms can be abstract (which is a dual-mode flag)
         // but they can never be one of ClassOnlyFlags
     if !sym.isClass && sym.isOneOf(ClassOnlyFlags) then
-      val illegal = sym.flags & ClassOnlyFlags
-      if sym.is(TypeParam) && illegal == Sealed && Feature.ccEnabled && cc.allowUniversalInBoxed then
-        if !sym.owner.is(Method) then
-          fail(em"only method type parameters can be sealed")
-      else
-        fail(em"only classes can be ${illegal.flagsString}")
+      fail(em"only classes can be ${(sym.flags & ClassOnlyFlags).flagsString}")
     if (sym.is(AbsOverride) && !sym.owner.is(Trait))
       fail(AbstractOverrideOnlyInTraits(sym))
     if sym.is(Trait) then

library/src/scala/caps.scala

@@ -44,9 +44,3 @@ import annotation.experimental
       def unsafeBoxFunArg: T => U = f
 
   end unsafe
-
-  /** An annotation that expresses the sealed modifier on a type parameter
-   *  Should not be directly referred to in source
-   */
-  @deprecated("The Sealed annotation should not be directly used in source code.\nUse the `sealed` modifier on type parameters instead.")
-  class Sealed extends annotation.Annotation

tests/neg-custom-args/captures/heal-tparam-cs.scala

@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Cap { def use(): Unit }
 
-def localCap[sealed T](op: (c: Cap^{cap}) => T): T = ???
+def localCap[T](op: (lcap: caps.Root) ?-> (c: Cap^{lcap}) => T): T = ???
 
 def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
 
@@ -11,7 +11,7 @@ def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
   }
 
   val test2: (c: Cap^{cap}) -> () ->{cap} Unit =
-    localCap { c =>  // should work
+    localCap { c =>  // error, was: should work
       (c1: Cap^{cap}) => () => { c1.use() }
     }
 
@@ -25,7 +25,7 @@ def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
       (c1: Cap^{io}) => () => { c1.use() }
     }
 
-  def localCap2[sealed T](op: (c: Cap^{io}) => T): T = ???
+  def localCap2[T](op: (c: Cap^{io}) => T): T = ???
 
   val test5: () ->{io} Unit =
     localCap2 { c =>  // ok

tests/neg-custom-args/captures/usingLogFile-alt.check

@@ -1,10 +1,10 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/usingLogFile-alt.scala:21:24 -----------------------------
-21 |      usingLogger(file)(l => () => l.log("test"))  // error
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^
-   |          Found:    (l: Test.Logger{val f: java.io.OutputStream^?}^{file}) ->? box () ->? Unit
-   |          Required: (x$0: Test.Logger^{file}) ->{'cap[..<root>](from instantiating usingLogger)} box () ->? Unit
+-- Error: tests/neg-custom-args/captures/usingLogFile-alt.scala:18:2 ---------------------------------------------------
+18 |  usingFile( // error
+   |  ^^^^^^^^^
+   |  reference (file : java.io.OutputStream^{lcap}) is not included in the allowed capture set {x$0, x$0²}
    |
-   |          Note that reference (cap[Logger] : caps.Root), defined at level 1
-   |          cannot be included in outer capture set ?, defined at level 0 in package <root>
+   |  Note that reference (file : java.io.OutputStream^{lcap}), defined at level 4
+   |  cannot be included in outer capture set {x$0, x$0}, defined at level 0 in package <root>
    |
-   | longer explanation available when compiling with `-explain`
+   |  where:    x$0  is a reference to a value parameter
+   |            x$0² is a reference to a value parameter

tests/neg-custom-args/captures/usingLogFile-alt.scala

@@ -7,17 +7,17 @@ object Test:
   class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
+  def usingFile[T](name: String, op: (lcap: caps.Root) ?-> OutputStream^{lcap} => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
     result
 
-  def usingLogger[sealed T](f: OutputStream^)(op: Logger^{f} => T): T = ???
+  def usingLogger[T](f: OutputStream^)(op: Logger^{f} => T): T = ???
 
-  usingFile(
+  usingFile( // error
     "foo",
     file => {
-      usingLogger(file)(l => () => l.log("test"))  // error
+      usingLogger(file)(l => () => l.log("test"))
     }
   )

tests/pos-custom-args/captures/i15749a.scala

@@ -1,3 +1,4 @@
+// TODO: Adapt to levels
 class Unit
 object u extends Unit
 
@@ -10,12 +11,12 @@ def test =
   def wrapper[T](x: T): Wrapper[T] =
     [X] => (op: T ->{cap} X) => op(x)
 
-  def strictMap[A <: Top, sealed B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
+  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
     mx((x: A) => wrapper(f(x)))
 
   def force[A](thunk: Unit ->{cap} A): A = thunk(u)
 
-  def forceWrapper[sealed A](mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[A](mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
     // Γ ⊢ mx: Wrapper[□ {cap} Unit => A]
     // `force` should be typed as ∀(□ {cap} Unit -> A) A, but it can not
     strictMap[Unit ->{cap} A, A](mx)(t => force[A](t)) // error

tests/pos-custom-args/captures/vars1.scala

@@ -1,26 +1,19 @@
 import caps.unsafe.*
-import annotation.unchecked.uncheckedCaptures
 
 object Test:
   type ErrorHandler = (Int, String) => Unit
 
-  @uncheckedCaptures
   var defaultIncompleteHandler: ErrorHandler = ???
-  @uncheckedCaptures
   var incompleteHandler: ErrorHandler = defaultIncompleteHandler
   private val x = incompleteHandler.unsafeUnbox
   val _ : ErrorHandler = x
   val _ = x(1, "a")
 
-  def defaultIncompleteHandler1(): (Int, String) => Unit = ???
+  def defaultIncompleteHandler1(): ErrorHandler = ???
   val defaultIncompleteHandler2: ErrorHandler = ???
-  @uncheckedCaptures
   var incompleteHandler1: ErrorHandler = defaultIncompleteHandler1()
-  @uncheckedCaptures
   var incompleteHandler2: ErrorHandler = defaultIncompleteHandler2
-  @uncheckedCaptures
   private var incompleteHandler7 = defaultIncompleteHandler1()
-  @uncheckedCaptures
   private var incompleteHandler8 = defaultIncompleteHandler2
 
   incompleteHandler1 = defaultIncompleteHandler2

tests/pos-special/stdlib/Test1.scala

@@ -6,7 +6,7 @@ import java.io.*
 
 object Test0:
 
-  def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+  def usingLogFile[T](op: (lcap: caps.Root) ?-> FileOutputStream^ => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()

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

@@ -32,7 +32,7 @@ import scala.collection.mutable
 import scala.util.control.NonFatal
 import scala.io.Codec
 import annotation.constructorOnly
-import annotation.unchecked.uncheckedCaptures
+import caps.unsafe.unsafeUnbox
 
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunInfo with ConstraintRunInfo {
@@ -165,7 +165,6 @@ class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunIn
   val staticRefs = util.EqHashMap[Name, Denotation](initialCapacity = 1024)
 
   /** Actions that need to be performed at the end of the current compilation run */
-  @uncheckedCaptures
   private var finalizeActions = mutable.ListBuffer[() => Unit]()
 
   /** Will be set to true if any of the compiled compilation units contains
@@ -276,7 +275,7 @@ class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunIn
       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/core/Scopes.scala

@@ -1,3 +1,8 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2012 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
 package dotty.tools
 package dotc
 package core
@@ -12,7 +17,6 @@ import Denotations._
 import printing.Texts._
 import printing.Printer
 import SymDenotations.NoDenotation
-import annotation.unchecked.uncheckedCaptures
 
 import collection.mutable
 
@@ -216,7 +220,6 @@ object Scopes {
     private var elemsCache: List[Symbol] | Null = null
 
     /** The synthesizer to be used, or `null` if no synthesis is done on this scope */
-    @uncheckedCaptures
     private var synthesize: SymbolSynthesizer | Null = null
 
     /** Use specified synthesize for this scope */