Centralize global language import set in Feature

Move the set of global language features (pureFunctions, captureChecking,
separationChecking, safe) into Feature.globalLanguageImports so that
ReplDriver and WrappedSnippet derive from a single source of truth.

Author: bracevac

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

@@ -248,10 +248,17 @@ object Feature:
   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
-   *  make the compilation unit's and current run's fields accordingly.
-   *  @return true iff import that was handled
+  /** Global language imports that affect parsing and must be handled specially.
+   *  These need per-compilation-unit flags (set in `handleGlobalLanguageImport`)
+   *  and also require propagation to rootCtx in the REPL and hoisting in the
+   *  snippet compiler so they take effect across inputs (i16250).
+   */
+  val globalLanguageImports: Set[TermName] =
+    Set(pureFunctions, captureChecking, separationChecking, safe)
+
+  /** Handle a global language import `import language.<prefix>.<imported>`.
+   *  Sets the compilation unit's and current run's fields accordingly.
+   *  @return true iff the import was handled
    */
   def handleGlobalLanguageImport(prefix: TermName, imported: Name)(using Context): Boolean =
     QualifiedName(prefix, imported.asTermName) match

repl/src/dotty/tools/repl/ReplDriver.scala

@@ -32,7 +32,7 @@ import dotc.reporting.Diagnostic
 import dotc.util.Spans.Span
 import dotc.util.{SourceFile, SourcePosition}
 import dotc.{CompilationUnit, Driver}
-import dotc.config.CompilerCommand
+import dotc.config.{CompilerCommand, Feature}
 import dotty.tools.io.{AbstractFileClassLoader => _, *}
 import dotty.tools.repl.ScalaClassLoader.*
 
@@ -309,23 +309,18 @@ class ReplDriver(settings: Array[String],
     val summary = rootCtx.settings.processArguments(List(s"-language:$feature"), true, rootCtx.settingsState)
     rootCtx = rootCtx.fresh.setSettings(summary.sstate)
 
-  /** Global language features that affect parsing and must be propagated to rootCtx (i16250). */
-  private val globalLanguageFeatures = Set(
-    "experimental.captureChecking", "experimental.pureFunctions",
-    "experimental.separationChecking", "experimental.safe")
-
-  /** Detect global language imports in parsed trees and enable them as settings (i16250). */
+  /** Detect global language imports in parsed trees and enable them in rootCtx
+   *  so subsequent parses and compilations see them (i16250).
+   */
   private def propagateLanguageImports(trees: List[untpd.Tree]): Unit =
-    for tree <- trees do
-      tree match
-        case untpd.Import(expr, selectors) =>
-          untpd.languageImport(expr) match
-            case Some(prefix) =>
-              for case untpd.ImportSelector(untpd.Ident(imported), untpd.EmptyTree, _) <- selectors do
-                val qual = if prefix.isEmpty then imported.toString else s"$prefix.$imported"
-                if globalLanguageFeatures.contains(qual) then
-                  enableLanguageFeature(qual)
-            case _ =>
+    import dotc.core.NameKinds.QualifiedName
+    for case untpd.Import(expr, selectors) <- trees do
+      untpd.languageImport(expr) match
+        case Some(prefix) =>
+          for case untpd.ImportSelector(untpd.Ident(imported), untpd.EmptyTree, _) <- selectors do
+            val qual = QualifiedName(prefix, imported.asTermName)
+            if Feature.globalLanguageImports.contains(qual) then
+              enableLanguageFeature(qual.toString)
         case _ =>
 
   private def stripBackTicks(label: String) =

scaladoc/src/dotty/tools/scaladoc/snippets/WrappedSnippet.scala

@@ -3,6 +3,7 @@ package snippets
 
 import java.io.ByteArrayOutputStream
 import java.io.PrintStream
+import dotty.tools.dotc.config.Feature
 
 case class WrappedSnippet(snippet: String, outerLineOffset: Int, outerColumnOffset: Int, innerLineOffset: Int, innerColumnOffset: Int)
 
@@ -12,7 +13,8 @@ object WrappedSnippet:
 
   /** Matches import lines for global language features that must be at the toplevel. */
   private val globalLanguageImport =
-    raw"import\s+language\s*\.\s*experimental\s*\.\s*(captureChecking|pureFunctions|separationChecking|safe)\b".r.unanchored
+    val names = Feature.globalLanguageImports.map(_.toString.stripPrefix("experimental."))
+    raw"import\s+language\s*\.\s*experimental\s*\.\s*(${names.mkString("|")})\b".r.unanchored
 
   private def isGlobalLanguageImport(line: String): Boolean =
     globalLanguageImport.matches(line.trim)