Exclude scala2macros from experimental checking

Also, some refactorings for simplicity.

Author: odersky

compiler/src/dotty/tools/dotc/Driver.scala

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

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -277,12 +277,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
         case _ => None
     case _ => None
 
-  def isLanguageImport(path: Tree): Boolean = languageImport(path).isDefined
-
-  def isExperimentalImport(path: Tree): Boolean = languageImport(path) match
-    case Some(nme.experimental) => true
-    case _ => false
-
   /** The underlying pattern ignoring any bindings */
   def unbind(x: Tree): Tree = unsplice(x) match {
     case Bind(_, y) => unbind(y)

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

@@ -214,4 +214,10 @@ object Config {
    *  reduces the number of allocated denotations by ~50%.
    */
   inline val reuseSymDenotations = true
+
+  /** Are experimental imports are allowed? By default same as
+   *  `Properties.experimental`. Can be re-assigned, e.g. to allow tests
+   *  of experimental features.
+   */
+  private[dotty] var allowExperimentalFeatures = Properties.experimental
 }

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

@@ -6,22 +6,22 @@ import core._
 import Contexts._, Symbols._, Names._, NameOps._, Phases._
 import StdNames.nme
 import Decorators.{_, given}
-import util.SrcPos
+import util.{SrcPos, NoSourcePosition}
 import SourceVersion._
 import reporting.Message
 import NameKinds.QualifiedName
 
 object Feature:
 
-  private def experimental(str: String): TermName =
+  def experimental(str: PreName): TermName =
     QualifiedName(nme.experimental, str.toTermName)
 
-  private def deprecated(str: String): TermName =
+  private def deprecated(str: PreName): TermName =
     QualifiedName(nme.deprecated, str.toTermName)
 
   private val namedTypeArguments = experimental("namedTypeArguments")
   private val genericNumberLiterals = experimental("genericNumberLiterals")
-  private val scala2macros = experimental("macros")
+  val scala2macros = experimental("macros")
 
   val dependent = experimental("dependent")
   val erasedDefinitions = experimental("erasedDefinitions")
@@ -97,15 +97,17 @@ object Feature:
     else
       false
 
-  val experimentalWarningMessage = "Experimental features may only be used with nightly or snapshot version of compiler."
+  def allowExperimentalFeatures(using Context) =
+    Config.allowExperimentalFeatures
+
+  def checkExperimentalFeature(which: String, srcPos: SrcPos = NoSourcePosition)(using Context) =
+    if !allowExperimentalFeatures then
+      report.error(i"Experimental feature$which may only be used with nightly or snapshot version of compiler", srcPos)
 
   /** Check that experimental compiler options are only set for snapshot or nightly compiler versions. */
-  def checkExperimentalFlags(using Context): Unit =
-    if !Properties.experimental then
-      val features = ctx.settings.language.value.filter(_.startsWith("experimental."))
-      if features.nonEmpty then
-        report.error(
-          i"""$experimentalWarningMessage
-             |The experimental language features were enabled via -language:$features%,%""")
+  def checkExperimentalSettings(using Context): Unit =
+    ctx.settings.language.value
+      .filter(str => str.startsWith("experimental.") && str != "experimental.scala2macros")
+      .foreach(str => checkExperimentalFeature(s" $str"))
 
 end Feature

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3078,20 +3078,24 @@ object Parsers {
     /** Create an import node and handle source version imports */
     def mkImport(outermost: Boolean = false): ImportConstr = (tree, selectors) =>
       val imp = Import(tree, selectors)
-      if isLanguageImport(tree) then
-        in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
-        if isExperimentalImport(tree) && !Properties.experimental then
-          report.error(Feature.experimentalWarningMessage, imp.srcPos)
-        for
-          case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors
-          if allSourceVersionNames.contains(imported)
-        do
-          if !outermost then
-            syntaxError(i"source version import is only allowed at the toplevel", id.span)
-          else if ctx.compilationUnit.sourceVersion.isDefined then
-            syntaxError(i"duplicate source version import", id.span)
-          else
-            ctx.compilationUnit.sourceVersion = Some(SourceVersion.valueOf(imported.toString))
+      languageImport(tree) match
+        case Some(prefix) =>
+          in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
+          if prefix == nme.experimental
+             && selectors.exists(sel => Feature.experimental(sel.name) != Feature.scala2macros)
+          then
+            Feature.checkExperimentalFeature("s", imp.srcPos)
+          for
+            case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors
+            if allSourceVersionNames.contains(imported)
+          do
+            if !outermost then
+              syntaxError(i"source version import is only allowed at the toplevel", id.span)
+            else if ctx.compilationUnit.sourceVersion.isDefined then
+              syntaxError(i"duplicate source version import", id.span)
+            else
+              ctx.compilationUnit.sourceVersion = Some(SourceVersion.valueOf(imported.toString))
+        case None =>
       imp
 
     /** ImportExpr       ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec

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

@@ -181,7 +181,7 @@ class ImportInfo(symf: Context ?=> Symbol,
       assert(myUnimported != null)
     myUnimported
 
-  private val isLanguageImport: Boolean = untpd.isLanguageImport(qualifier)
+  private val isLanguageImport: Boolean = untpd.languageImport(qualifier).isDefined
 
   private var myUnimported: Symbol = _