Do not enable experimental by default in nightly and snapshot versions

This scheme was devised as a simple way to enable experimental on non-stable
released. This made it impossible to publish a library containing experimental
features for a non-experimental version of the compiler. We had `-Yno-experimental`
to test the expected behavior on stable releases. Later we added `-experimental`
which add `@experimental` to all top-level classes. On a stable release, this
has the same effect as enabling experimental features, but it also allows
publishing this library (users will need to also be experimental to use it).

We can use `-experimental` on nightly and snapshot releases to achieve the
same behavior as before. By doing this the `-Yno-experimental` flag is no
longer needed and can be removed.

We will need to use `-experimental` in all our tests to enable experimental
by default. We can add this compiler flag to the default settings. We
also need a few tests that do not use `-experimental` to test the behavior
of `@experimental`. These can be added in `tests/*-no-experimental/`. Not
all tests have `-experimental` enabled, this will be added on a need basis.

With this we detected one bug, the runtime staging compile crashes if the
code uses experimental features. To fix this we enable `-experimental` by
default in this compiler. Note that the experimental-ness checks will have
been done by the compiler that compiled the quotes.

Author: nicolasstucki

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

@@ -136,8 +136,7 @@ object Feature:
       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. Compiling with the -experimental compiler flag$note
           """, srcPos)
 
   private def ccException(sym: Symbol)(using Context): Boolean =
@@ -163,7 +162,7 @@ object Feature:
     do checkExperimentalFeature(s"feature $setting", NoSourcePosition)
 
   def isExperimentalEnabled(using Context): Boolean =
-    (Properties.experimental || ctx.settings.experimental.value) && !ctx.settings.YnoExperimental.value
+    ctx.settings.experimental.value
 
   /** 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/config/Properties.scala

@@ -84,13 +84,8 @@ trait PropertiesTrait {
    */
   val versionString: String = "version " + simpleVersionString
 
-  /** Whether the current version of compiler is experimental
-   *
-   *  1. Snapshot, nightly releases and non-bootstrapped compiler are experimental.
-   *  2. Features supported by experimental versions of the compiler:
-   *     - research plugins
-   */
-  val experimental: Boolean = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY") || versionString.contains("nonbootstrapped")
+  /** Whether the current version of supports research plugins */
+  val researchPluginsEnabled: Boolean = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY") || versionString.contains("nonbootstrapped")
 
   val copyrightString: String       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
 

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

@@ -397,7 +397,6 @@ private sealed trait YSettings:
   val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
   val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")
   val YfromTastyIgnoreList: Setting[List[String]] = MultiStringSetting("-Yfrom-tasty-ignore-list", "file", "List of `tasty` files in jar files that will not be loaded when using -from-tasty.")
-  val YnoExperimental: Setting[Boolean] = BooleanSetting("-Yno-experimental", "Disable experimental language features.")
   val YlegacyLazyVals: Setting[Boolean] = BooleanSetting("-Ylegacy-lazy-vals", "Use legacy (pre 3.3.0) implementation of lazy vals.")
   val YcompileScala2Library: Setting[Boolean] = BooleanSetting("-Ycompile-scala2-library", "Used when compiling the Scala 2 standard library.")
   val YoutputOnlyTasty: Setting[Boolean] = BooleanSetting("-Youtput-only-tasty", "Used to only generate the TASTy file without the classfiles")

compiler/src/dotty/tools/dotc/plugins/Plugins.scala

@@ -129,7 +129,7 @@ trait Plugins {
     val updatedPlan = Plugins.schedule(plan, pluginPhases)
 
     // add research plugins
-    if Properties.experimental && !ctx.settings.YnoExperimental.value then
+    if Properties.researchPluginsEnabled then
       plugins.collect { case p: ResearchPlugin => p }.foldRight(updatedPlan) {
         (plug, plan) => plug.init(options(plug), plan)
       }

compiler/test/dotty/tools/DottyTest.scala

@@ -40,6 +40,7 @@ trait DottyTest extends ContextEscapeDetection {
   protected def initializeCtx(fc: FreshContext): Unit = {
     fc.setSetting(fc.settings.encoding, "UTF8")
     fc.setSetting(fc.settings.classpath, TestConfiguration.basicClasspath)
+    fc.setSetting(fc.settings.experimental, true)
     fc.setSetting(fc.settings.language, List("experimental.erasedDefinitions"))
     fc.setProperty(ContextDoc, new ContextDocstrings)
   }

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

@@ -29,6 +29,7 @@ class BootstrappedOnlyCompilationTests {
     aggregateTests(
       compileFilesInDir("tests/bench", defaultOptions.without("-Yno-deep-subtypes")),
       compileFilesInDir("tests/pos-macros", defaultOptions.and("-Xcheck-macros")),
+      compileFilesInDir("tests/pos-no-experimental", defaultOptions.without("-experimental")),
     ).checkCompile()
   }
 
@@ -104,8 +105,10 @@ class BootstrappedOnlyCompilationTests {
 
   @Test def negMacros: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileNegWithCompiler")
-    compileFilesInDir("tests/neg-macros", defaultOptions.and("-Xcheck-macros"))
-      .checkExpectedErrors()
+    aggregateTests(
+      compileFilesInDir("tests/neg-macros", defaultOptions.and("-Xcheck-macros")),
+      compileFilesInDir("tests/neg-no-experimental", defaultOptions.without("-experimental")),
+    ).checkExpectedErrors()
   }
 
   @Test def negWithCompiler: Unit = {
@@ -120,8 +123,10 @@ class BootstrappedOnlyCompilationTests {
 
   @Test def runMacros: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runMacros")
-    compileFilesInDir("tests/run-macros", defaultOptions.and("-Xcheck-macros"), FileFilter.exclude(TestSources.runMacrosScala2LibraryTastyBlacklisted))
-      .checkRuns()
+    aggregateTests(
+      compileFilesInDir("tests/run-macros", defaultOptions.and("-Xcheck-macros"), FileFilter.exclude(TestSources.runMacrosScala2LibraryTastyBlacklisted)),
+      compileFilesInDir("tests/run-no-experimental", defaultOptions.without("-experimental")),
+    ).checkRuns()
   }
 
   @Test def runWithCompiler: Unit = {

compiler/test/dotty/tools/repl/ReplTest.scala

@@ -104,6 +104,6 @@ extends ReplDriver(options, new PrintStream(out, true, StandardCharsets.UTF_8.na
   }
 
 object ReplTest:
-  val commonOptions = Array("-color:never", "-language:experimental.erasedDefinitions", "-pagewidth", "80")
+  val commonOptions = Array("-color:never", "-pagewidth", "80")
   val defaultOptions = commonOptions ++ Array("-classpath", TestConfiguration.basicClasspath)
   lazy val withStagingOptions = commonOptions ++ Array("-classpath", TestConfiguration.withStagingClasspath)

compiler/test/dotty/tools/repl/ScriptedTests.scala

@@ -6,7 +6,7 @@ import org.junit.Test
 import org.junit.experimental.categories.Category
 
 /** Runs all tests contained in `compiler/test-resources/repl/` */
-class ScriptedTests extends ReplTest {
+class ScriptedTests extends ReplTest(ScriptedTests.options) {
 
   @Test def replTests = scripts("/repl").foreach(testFile)
 
@@ -17,4 +17,5 @@ class ScriptedTests extends ReplTest {
 }
 
 object ScriptedTests {
+  val options = Array("-experimental", "-language:experimental.erasedDefinitions") ++ ReplTest.defaultOptions
 }

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -65,7 +65,7 @@ object TestConfiguration {
 
   val yCheckOptions = Array("-Ycheck:all")
 
-  val commonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
+  val commonOptions = Array("-indent", "-experimental") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
   val defaultOptions = TestFlags(basicClasspath, commonOptions)
   val unindentOptions = TestFlags(basicClasspath, Array("-no-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions)
   val withCompilerOptions =