Enable experimental mode when experimental feature is imported

The `@experimental` flag is added to definitions in the scope where the the experimental language feature is imported.

Author: nicolasstucki

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

@@ -32,6 +32,22 @@ object Feature:
  val pureFunctions = experimental("pureFunctions")
  val captureChecking = experimental("captureChecking")
  val into = experimental("into")
+ val relaxedExtensionImports = experimental("relaxedExtensionImports")
+
+ // TODO compute this list
+ // TODO remove features that do not enable experimental mode
+ val experimentalAutoEnableFeatures: List[TermName] = List(
+ namedTypeArguments,
+ genericNumberLiterals,
+ erasedDefinitions,
+ fewerBraces,
+ saferExceptions,
+ clauseInterleaving,
+ pureFunctions,
+ captureChecking,
+ into,
+ relaxedExtensionImports,
+ )
 
  val globalOnlyImports: Set[TermName] = Set(pureFunctions, captureChecking)
 
@@ -132,19 +148,20 @@ object Feature:
  false
 
  def checkExperimentalFeature(which: String, srcPos: SrcPos, note: => String = "")(using Context) =
- if !isExperimentalEnabled then
+ if !isExperimentalGloballyEnabled && !isExperimentalByImportEnabled && !isExperimentalUnstableEnabled then
  report.error(
  em"""Experimental $which may only be used under experimental mode:
  | 1. In a definition marked as @experimental
- | 2. Compiling with the -experimental compiler flag
- | 3. With a nightly or snapshot version of the compiler$note
+ | 2. An experimental language import is in scope or within the current definition
+ | 3. Compiling with the -experimental compiler flag
+ | 4. 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 !isExperimentalGloballyEnabled && !isExperimentalByImportEnabled && !isExperimentalUnstableEnabled then
  val experimentalSym =
  if sym.hasAnnotation(defn.ExperimentalAnnot) then sym
  else if sym.owner.hasAnnotation(defn.ExperimentalAnnot) then sym.owner
@@ -162,8 +179,22 @@ object Feature:
  if setting.startsWith("experimental.") && setting != "experimental.macros"
  do checkExperimentalFeature(s"feature $setting", NoSourcePosition)
 
- def isExperimentalEnabled(using Context): Boolean =
- (Properties.experimental && !ctx.settings.YnoExperimental.value) || ctx.settings.experimental.value
+
+ /** Experimental mode enabled by default in nightly or snapshot version of the compiler without `-Yno-experimental` */
+ def isExperimentalUnstableEnabled(using Context): Boolean =
+ Properties.experimental && !ctx.settings.YnoExperimental.value
+
+ /** Experimental mode enabled in this compilation unit
+ * - Compiled with `-experimental`
+ * - Compiled with `-language:experimental.xyz`
+ */
+ def isExperimentalGloballyEnabled(using Context): Boolean =
+ ctx.settings.experimental.value ||
+ experimentalAutoEnableFeatures.exists(enabledBySetting)
+
+ /** Experimental mode enabled by a `language.experimental` import in scope */
+ def isExperimentalByImportEnabled(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/SymDenotations.scala

@@ -1254,6 +1254,19 @@ object SymDenotations {
  final def isTopLevelClass(using Context): Boolean =
  !this.exists || this.isEffectiveRoot || this.is(PackageClass) || this.owner.is(PackageClass)
 
+ /** The top-level definition containing this denotation.
+ * Returns top-level class or members of top-level package objects.
+ * If this is not in a definition, returns NoSymbol.
+ */
+ @tailrec final def topLevelDefinition(using Context): Symbol =
+ if !this.exists || this.is(Package) then NoSymbol
+ else if this.isTopLevelDefinition then this.symbol
+ else this.owner.topLevelDefinition
+
+ final def isTopLevelDefinition(using Context): Boolean =
+ !this.is(Package) && !this.name.isPackageObjectName &&
+ (this.owner.is(Package) || (this.owner.isPackageObject && !this.isConstructor))
+
  /** The package class containing this denotation */
  final def enclosingPackageClass(using Context): Symbol =
  if (this.is(PackageClass)) symbol else owner.enclosingPackageClass

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

@@ -545,15 +545,22 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
  report.error("`erased` definition cannot be implemented with en expression of type Null", tree.srcPos)
 
  private def annotateExperimental(sym: Symbol)(using Context): Unit =
- def isTopLevelDefinitionInSource(sym: Symbol) =
- !sym.is(Package) && !sym.name.isPackageObjectName &&
- (sym.owner.is(Package) || (sym.owner.isPackageObject && !sym.isConstructor))
- if !sym.hasAnnotation(defn.ExperimentalAnnot)
- && (ctx.settings.experimental.value && isTopLevelDefinitionInSource(sym))
- || (sym.is(Module) && sym.companionClass.hasAnnotation(defn.ExperimentalAnnot))
- then
+ def companionOfExperimental =
+ sym.is(Module) && sym.companionClass.hasAnnotation(defn.ExperimentalAnnot)
+ def topLevelDefinitionWithExperimentalEnabledInUnit =
+ sym.isTopLevelDefinition && (Feature.isExperimentalGloballyEnabled || Feature.isExperimentalByImportEnabled)
+ if !sym.hasAnnotation(defn.ExperimentalAnnot) && (companionOfExperimental || topLevelDefinitionWithExperimentalEnabledInUnit) then
  sym.addAnnotation(Annotation(defn.ExperimentalAnnot, sym.span))
 
+ // TODO do this on import statement
+ val topLevelDefinition = sym.topLevelDefinition
+ if topLevelDefinition.exists &&
+ !topLevelDefinition.hasAnnotation(defn.ExperimentalAnnot)
+ && Feature.isExperimentalByImportEnabled
+ then
+ topLevelDefinition.addAnnotation(Annotation(defn.ExperimentalAnnot, sym.span))
+ if topLevelDefinition.is(Module) then topLevelDefinition.companionModule.addAnnotation(Annotation(defn.ExperimentalAnnot, sym.span))
+
  private def scala2LibPatch(tree: TypeDef)(using Context) =
  val sym = tree.symbol
  if compilingScala2StdLib && sym.is(ModuleClass) then

compiler/test/dotty/tools/dotc/TastyBootstrapTests.scala

@@ -60,7 +60,6 @@ class TastyBootstrapTests {
  val lib =
  compileList("lib", librarySources,
  defaultOptions.and("-Ycheck-reentrant",
- "-language:experimental.erasedDefinitions", // support declaration of scala.compiletime.erasedValue
  // "-source", "future", // TODO: re-enable once library uses updated syntax for vararg splices, wildcard imports, and import renaming
  ))(libGroup)
 

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 the current scope
+
+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.

docs/_spec/TODOreference/other-new-features/experimental-defs.md

@@ -216,7 +216,7 @@ Experimental definitions can only be referenced in an experimental scope. Experi
 
  <details>
  <summary>Example 1</summary>
- 
+
  ```scala
  import scala.annotation.experimental
 
@@ -242,7 +242,7 @@ Experimental definitions can only be referenced in an experimental scope. Experi
  }
  }
  ```
- 
+
  </details>
 
 5. Annotations of an experimental definition are in experimental scopes. Examples:
@@ -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 the current scope
+
+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.