Special handling of experimental.captureChecking import

The question is, how do we introduce capture checking safely. There are
two conflicting requirements:

 - Capture checking should not leak into standard Scala. It should be
   meaningful only in code that has capture checking explicitly enabled.
 - We need to be able to build up libraries that express capture information
   and that can be consumed from other code. This needs to start with
   the standard library itself.

So far, everything related to capture checking was marked experimental. This means
all code that refers to a capture checking abstraction in any way whatsoever needs
to be declared experimental. That clearly does not work for the new use cases.

But fortunately, capture checking has some properties that enable a different scheme.
Specifically, a file compiled under capture checking looks like a completely normal
component (both Tasty and binary) to any other file that uses it and that is not compiled
with captureChecking. Only when the consumer is also compiled with capture checking,
the capturing types of the original file will be revealed. The same holds for binaries.
Capture checking has no effect at all on the binaries that get generated and all types
and annotations needed for capture checking are erased.

This allows the following more flexible scheme:

 - We can turn capture checking on with a setting or language import in any source file.
   The sources do not have to be @experimental.
 - If capture checking is turned on, a number of annotations and other symbols that
   are normally experimental are also made available.

The important property is that capture checking in one component cannot poison other normal components. Like
@experimental itself, the whole scheme is transitive.

With the new scheme we do not need a special exemption for the dotty package anymore, so that part
is dropped.

Author: odersky

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -136,8 +136,11 @@ object Feature:
     if !isExperimentalEnabled then
       report.error(em"Experimental $which may only be used with a nightly or snapshot version of the compiler$note", srcPos)
 
+  private def ccException(sym: Symbol)(using Context): Boolean =
+    ccEnabled && defn.ccExperimental.contains(sym) 
+
   def checkExperimentalDef(sym: Symbol, srcPos: SrcPos)(using Context) =
-    if !isExperimentalEnabled then
+    if !isExperimentalEnabled && !ccException(sym) then
       val symMsg =
         if sym.hasAnnotation(defn.ExperimentalAnnot) then
           i"$sym is marked @experimental"

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

@@ -1945,6 +1945,14 @@ class Definitions {
       case Some(pkgs) => pkgs.contains(sym.owner)
       case none => false
 
+  /** Experimental definitions that can nevertheless be accessed from a stable
+   *  compiler if capture checking is enabled.
+   */
+  @tu lazy val ccExperimental: Set[Symbol] = Set(
+    CapsModule, CapsModule.moduleClass, PureClass,
+    CapabilityAnnot, RequiresCapabilityAnnot,
+    RetainsAnnot, RetainsByNameAnnot, WithPureFunsAnnot)
+
   // ----- primitive value class machinery ------------------------------------------
 
   class PerRun[T](generate: Context ?=> T) {

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

@@ -410,7 +410,7 @@ object TypeErasure {
             val candidates = takeUntil(tp2superclasses)(!_.is(Trait))
 
             // Candidates st "no other common superclass or trait derives from S"
-            // Also, drop `PairClass` since it is not valid after erasue
+            // Also, drop `PairClass` since it is not valid after erasure
             val minimums = candidates.filter { cand =>
               cand != defn.PairClass
               && candidates.forall(x => !x.derivesFrom(cand) || x.eq(cand))

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

@@ -784,7 +784,9 @@ object Checking {
     for case imp @ Import(qual, selectors) <- trees do
       def isAllowedImport(sel: untpd.ImportSelector) =
         val name = Feature.experimental(sel.name)
-        name == Feature.scala2macros || name == Feature.erasedDefinitions
+        name == Feature.scala2macros
+        || name == Feature.erasedDefinitions
+        || name == Feature.captureChecking
 
       languageImport(qual) match
         case Some(nme.experimental)

tests/pos-custom-args/no-experimental/cc-experimental.scala

@@ -0,0 +1,11 @@
+package scala.runtime
+
+import language.experimental.captureChecking
+
+object test:
+  type T = Pure
+
+class Foo extends Object, Pure:
+  val x: Pure = ???
+  def foo() = ()
+