Enable experimental mode when experimental feature is imported

The `@experimental` flag is added to top-level definitions in the package
where the language feature is imported.

Author: nicolasstucki

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

@@ -136,8 +136,9 @@ object Feature:
       report.error(
         em"""Experimental $which may only be used under experimental mode:
             |  1. in a definition marked as @experimental, or
-            |  2. compiling with the -experimental compiler flag, or
-            |  3. with a nightly or snapshot version of the compiler.$note
+            |  2. an experimental feature is imported in at the package level, or
+            |  3. compiling with the -experimental compiler flag, or
+            |  4. with a nightly or snapshot version of the compiler.$note
           """, srcPos)
 
   private def ccException(sym: Symbol)(using Context): Boolean =

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

@@ -806,23 +806,22 @@ object Checking {
    *  scope with only @experimental definitions.
    */
   def checkExperimentalImports(trees: List[Tree])(using Context): Unit =
-
-    def nonExperimentalStat(trees: List[Tree]): Tree = trees match
-      case (_: Import | EmptyTree) :: rest =>
-        nonExperimentalStat(rest)
+    def nonExperimentalStats(trees: List[Tree]): List[Tree] = trees match
+      case (_: ImportOrExport | EmptyTree) :: rest =>
+        nonExperimentalStats(rest)
       case (tree @ TypeDef(_, impl: Template)) :: rest if tree.symbol.isPackageObject =>
-        nonExperimentalStat(impl.body).orElse(nonExperimentalStat(rest))
+        nonExperimentalStats(impl.body) ::: nonExperimentalStats(rest)
       case (tree: PackageDef) :: rest =>
-        nonExperimentalStat(tree.stats).orElse(nonExperimentalStat(rest))
+        nonExperimentalStats(tree.stats) ::: nonExperimentalStats(rest)
       case (tree: MemberDef) :: rest =>
         if tree.symbol.isExperimental || tree.symbol.is(Synthetic) then
-          nonExperimentalStat(rest)
+          nonExperimentalStats(rest)
         else
-          tree
+          tree :: nonExperimentalStats(rest)
       case tree :: rest =>
-        tree
+        tree :: nonExperimentalStats(rest)
       case Nil =>
-        EmptyTree
+        Nil
 
     for case imp @ Import(qual, selectors) <- trees do
       def isAllowedImport(sel: untpd.ImportSelector) =
@@ -838,11 +837,16 @@ object Checking {
             Feature.checkExperimentalFeature("features", imp.srcPos,
               s"\n\nNote: the scope enclosing the import is not considered experimental because it contains the\nnon-experimental $stable")
           if ctx.owner.is(Package) then
-            // allow top-level experimental imports if all definitions are @experimental
-            nonExperimentalStat(trees) match
-              case EmptyTree =>
-              case tree: MemberDef => check(i"${tree.symbol}")
-              case tree => check(i"expression ${tree}")
+            // mark all top-level definitions as @experimental
+            for tree <- nonExperimentalStats(trees) do
+              tree match
+                case tree: MemberDef =>
+                  // TODO move this out of checking (into posttyper?)
+                  val sym = tree.symbol
+                  if !sym.isExperimental then
+                    sym.addAnnotation(Annotations.Annotation(defn.ExperimentalAnnot, sym.span))
+                case tree =>
+                  check(i"expression ${tree}")
           else Feature.checkExperimentalFeature("features", imp.srcPos)
         case _ =>
   end checkExperimentalImports

docs/_docs/reference/other-new-features/experimental-defs.md

@@ -265,7 +265,9 @@ Experimental definitions can only be referenced in an experimental scope. Experi
 
    </details>
 
-6. Any code compiled using a [_Nightly_](https://search.maven.org/artifact/org.scala-lang/scala3-compiler_3) or _Snapshot_ version of the compiler is considered to be in an experimental scope.
+6. An experimental language feature is imported in at the package level
+
+7. Any code compiled using a [_Nightly_](https://search.maven.org/artifact/org.scala-lang/scala3-compiler_3) or _Snapshot_ version of the compiler is considered to be in an experimental scope.
 Can use the `-Yno-experimental` compiler flag to disable it and run as a proper release.
 
 In any other situation, a reference to an experimental definition will cause a compilation error.

tests/neg/expeimental-flag-with-lang-feature-2.scala renamed to tests/pos/expeimental-flag-with-lang-feature-2.scala

@@ -1,6 +1,6 @@
 //> using options -Yno-experimental
 
-import scala.language.experimental.namedTypeArguments // error
+import scala.language.experimental.namedTypeArguments
 
 def namedTypeArgumentsFun[T, U]: Int =
   namedTypeArgumentsFun[T = Int, U = Int]

tests/neg/experimental-package-imports.scala renamed to tests/pos/experimental-package-imports.scala

@@ -3,12 +3,12 @@
 import annotation.experimental
 
 package foo {
-  import language.experimental.namedTypeArguments // error
-  import language.experimental.genericNumberLiterals // error
-  import language.experimental.erasedDefinitions // ok: only check at erased definition
+  import language.experimental.namedTypeArguments
+  import language.experimental.genericNumberLiterals
+  import language.experimental.erasedDefinitions
 
   package bar {
-    def foo = 1
+    def foo = 1 // marked as @experimental because of the language imports
   }
 }
 

tests/pos/interleaving-chainedParams.scala

@@ -1,11 +1,13 @@
+//> using options -Yno-experimental
+
 import scala.language.experimental.clauseInterleaving
 
 object chainedParams{
 
   trait Chain{
       type Tail <: Chain
   }
-  
+
   def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
 
   val self = new Chain{ type Tail = this.type }