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/Driver.scala

@@ -77,7 +77,6 @@ class Driver {
     val ictx = rootCtx.fresh
     val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
     ictx.setSettings(summary.sstate)
-    Feature.checkExperimentalSettings(using ictx)
     MacroClassLoader.init(ictx)
     Positioned.init(using ictx)
 

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

@@ -34,6 +34,11 @@ object Feature:
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
 
+  def experimentalAutoEnableFeatures(using Context): List[TermName] =
+    defn.languageExperimentalFeatures
+      .map(sym => experimental(sym.name))
+      .filterNot(_ == captureChecking) // TODO is this correct?
+
   /** Is `feature` enabled by by a command-line setting? The enabling setting is
    *
    *       -language:<prefix>feature
@@ -157,18 +162,23 @@ object Feature:
   private def experimentalUseSite(which: String): String =
     s"""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.
+       |  2. an experimental feature is imported at the package level, or
+       |  3. compiling with the -experimental compiler flag, or
+       |  4. with a nightly or snapshot version of the compiler.
        |""".stripMargin
 
-  /** Check that experimental compiler options are only set for snapshot or nightly compiler versions. */
-  def checkExperimentalSettings(using Context): Unit =
-    for setting <- ctx.settings.language.value
-        if setting.startsWith("experimental.") && setting != "experimental.macros"
-    do checkExperimentalFeature(s"feature $setting", NoSourcePosition)
-
   def isExperimentalEnabled(using Context): Boolean =
-    (Properties.unstableExperimentalEnabled && !ctx.settings.YnoExperimental.value) || ctx.settings.experimental.value
+    (Properties.unstableExperimentalEnabled && !ctx.settings.YnoExperimental.value) ||
+    ctx.settings.experimental.value ||
+    experimentalAutoEnableFeatures.exists(enabled)
+
+  def isExperimentalEnabledBySetting(using Context): Boolean =
+    (Properties.unstableExperimentalEnabled && !ctx.settings.YnoExperimental.value) ||
+    ctx.settings.experimental.value ||
+    experimentalAutoEnableFeatures.exists(enabledBySetting)
+
+  def isExperimentalEnabledByImport(using Context): Boolean =
+    experimentalAutoEnableFeatures.exists(enabledByImport)
 
   /** Handle language import `import language.<prefix>.<imported>` if it is one
    *  of the global imports `pureFunctions` or `captureChecking`. In this case

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

@@ -2007,6 +2007,13 @@ class Definitions {
     CapabilityAnnot, RequiresCapabilityAnnot,
     RetainsAnnot, RetainsCapAnnot, RetainsByNameAnnot)
 
+  /** Experimental language features defined in `scala.runtime.stdLibPatches.language.experimental`.
+   *
+   *  This list does not include `scala.language.experimental.macros`.
+   */
+  @tu lazy val languageExperimentalFeatures: List[TermSymbol] =
+    LanguageExperimentalModule.moduleClass.info.decls.toList.filter(_.isAllOf(Lazy | Module)).map(_.asTerm)
+
   // ----- primitive value class machinery ------------------------------------------
 
   class PerRun[T](generate: Context ?=> T) {

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -545,8 +545,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       }
 
     override def transformStats[T](trees: List[Tree], exprOwner: Symbol, wrapResult: List[Tree] => Context ?=> T)(using Context): T =
-      try super.transformStats(trees, exprOwner, wrapResult)
-      finally Checking.checkExperimentalImports(trees)
+      Checking.checkAndAdaptExperimentalImports(trees)
+      super.transformStats(trees, exprOwner, wrapResult)
 
     /** Transforms the rhs tree into a its default tree if it is in an `erased` val/def.
      *  Performed to shrink the tree that is known to be erased later.
@@ -589,8 +589,10 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         (sym.owner.is(Package) || (sym.owner.isPackageObject && !sym.isConstructor))
       if sym.is(Module) then
         ExperimentalAnnotation.copy(sym.companionClass).foreach(sym.addAnnotation)
-      if !sym.hasAnnotation(defn.ExperimentalAnnot) && ctx.settings.experimental.value && isTopLevelDefinitionInSource(sym) then
-        sym.addAnnotation(ExperimentalAnnotation("Added by -experimental", sym.span))
+      if !sym.hasAnnotation(defn.ExperimentalAnnot)
+        && Feature.isExperimentalEnabledBySetting && isTopLevelDefinitionInSource(sym)
+      then
+        sym.addAnnotation(ExperimentalAnnotation("Added by -experimental or -language:experimental.*", sym.span))
 
     // It needs to run at the phase of the postTyper --- otherwise, the test of the symbols will use
     // the transformed denotation with added `Serializable` and `AbstractFunction1`.

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

@@ -42,6 +42,7 @@ import cc.{isCaptureChecking, isRetainsLike}
 
 import collection.mutable
 import reporting.*
+import Annotations.ExperimentalAnnotation
 
 object Checking {
   import tpd.*
@@ -802,50 +803,53 @@ object Checking {
     tree
 
   /** Check that experimental language imports in `trees`
-   *  are done only in experimental scopes, or in a top-level
-   *  scope with only @experimental definitions.
+   *  are done only in experimental scopes. For for top-level
+   *  experimental imports, all top-level definitions are transformed
+   *  to @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 checkAndAdaptExperimentalImports(trees: List[Tree])(using Context): Unit =
+    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) =
         val name = Feature.experimental(sel.name)
         name == Feature.scala2macros
-        || name == Feature.erasedDefinitions
         || name == Feature.captureChecking
 
       languageImport(qual) match
         case Some(nme.experimental)
         if !ctx.owner.isInExperimentalScope && !selectors.forall(isAllowedImport) =>
-          def check(stable: => String) =
-            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}")
-          else Feature.checkExperimentalFeature("features", imp.srcPos)
+          if ctx.owner.is(Package) || ctx.owner.name.startsWith(str.REPL_SESSION_LINE) then
+            // 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(ExperimentalAnnotation(i"Added by top level $imp", sym.span))
+                case tree =>
+                  // There is no definition to attach the @experimental annotation
+                  report.error("Implementation restriction: top-level `val _ = ...` is not supported with experimental language imports.", tree.srcPos)
+          else Feature.checkExperimentalFeature("feature local import", imp.srcPos)
         case _ =>
-  end checkExperimentalImports
+  end checkAndAdaptExperimentalImports
 
   /** Checks that PolyFunction only have valid refinements.
    *

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

@@ -132,12 +132,14 @@ class CrossVersionChecks extends MiniPhase:
   }
 
   override def transformOther(tree: Tree)(using Context): Tree =
-    tree.foreachSubTree { // Find references in type trees and imports
-      case tree: Ident => transformIdent(tree)
-      case tree: Select => transformSelect(tree)
-      case tree: TypeTree => transformTypeTree(tree)
-      case _ =>
-    }
+    val inPackage = ctx.owner.is(Package) || ctx.owner.isPackageObject
+    if !(inPackage && tree.isInstanceOf[ImportOrExport] && Feature.isExperimentalEnabledByImport) then
+      tree.foreachSubTree { // Find references in type trees and imports
+        case tree: Ident => transformIdent(tree)
+        case tree: Select => transformSelect(tree)
+        case tree: TypeTree => transformTypeTree(tree)
+        case _ =>
+      }
     tree
 
 end CrossVersionChecks

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

@@ -268,6 +268,8 @@ Experimental definitions can only be referenced in an experimental scope. Experi
 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.
 Can use the `-Yno-experimental` compiler flag to disable it and run as a proper release.
 
+7. An experimental language feature is imported in at the package level. All top-level definitions will be marked as `@experimental`.
+
 In any other situation, a reference to an experimental definition will cause a compilation error.
 
 ## Experimental overriding

tests/neg-macros/i18677-a.check

@@ -7,10 +7,10 @@
   |The tree does not conform to the compiler's tree invariants.
   |
   |Macro was:
-  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-a/Test_2.scala") @scala.annotation.experimental("Added by -experimental") @extendFoo class AFoo()
+  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-a/Test_2.scala") @scala.annotation.experimental("Added by -experimental or -language:experimental.*") @extendFoo class AFoo()
   |
   |The macro returned:
-  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-a/Test_2.scala") @scala.annotation.experimental("Added by -experimental") @extendFoo class AFoo() extends Foo
+  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-a/Test_2.scala") @scala.annotation.experimental("Added by -experimental or -language:experimental.*") @extendFoo class AFoo() extends Foo
   |
   |Error:
   |assertion failed: Parents of class symbol differs from the parents in the tree for class AFoo

tests/neg-macros/i18677-b.check

@@ -7,10 +7,10 @@
   |The tree does not conform to the compiler's tree invariants.
   |
   |Macro was:
-  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-b/Test_2.scala") @scala.annotation.experimental("Added by -experimental") @extendFoo class AFoo()
+  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-b/Test_2.scala") @scala.annotation.experimental("Added by -experimental or -language:experimental.*") @extendFoo class AFoo()
   |
   |The macro returned:
-  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-b/Test_2.scala") @scala.annotation.experimental("Added by -experimental") @extendFoo class AFoo() extends Foo
+  |@scala.annotation.internal.SourceFile("tests/neg-macros/i18677-b/Test_2.scala") @scala.annotation.experimental("Added by -experimental or -language:experimental.*") @extendFoo class AFoo() extends Foo
   |
   |Error:
   |assertion failed: Parents of class symbol differs from the parents in the tree for class AFoo