Only run macro tests with a bootstrapped compiler

Compiling a macro with a non-bootstrapped compiler is fine, but running
that macro in a subsequent compiler run as is usually done in macro
tests is problematic since the MacroClassLoader is created using the
compiler classpath (which contains a bootstrapped library) with the
regular JVM classpath as parent classloader (which contains a
non-bootstrapped library), this is inconsistent and could lead to various
weird problems depending on the order in which things get loaded.

One possible way to run these tests would be to always put the
bootstrapped library on the JVM classpath, even if we're using the
non-bootstrapped compiler, but this would cause test failures every time
we would break binary compatibility.

Instead, this commit moves the relevant tests to {pos,neg,run}-macros
which will only be run with a bootstrapped compiler. To speed up
development, it might be useful to add a flag to `testCompilation` that
would put the bootstrapped library on the JVM classpath and still run
these tests, but this is left as future work.

Author: smarter

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

@@ -29,6 +29,11 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
 
   // Positive tests ------------------------------------------------------------
 
+  @Test def posMacros: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("compilePosMacros")
+    compileFilesInDir("tests/pos-macros", defaultOptions)
+  }.checkCompile()
+
   @Test def posWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compilePosWithCompiler")
     compileFilesInDir("tests/pos-with-compiler", withCompilerOptions) +
@@ -69,13 +74,23 @@ class BootstrappedOnlyCompilationTests extends ParallelTesting {
 
   // Negative tests ------------------------------------------------------------
 
-  @Test def negAll: Unit = {
+  @Test def negMacros: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("compileNegWithCompiler")
+    compileFilesInDir("tests/neg-macros", defaultOptions)
+  }.checkExpectedErrors()
+
+  @Test def negWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileNegWithCompiler")
     compileFilesInDir("tests/neg-with-compiler", withCompilerOptions)
   }.checkExpectedErrors()
 
   // Run tests -----------------------------------------------------------------
 
+  @Test def runMacros: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("runMacros")
+    compileFilesInDir("tests/run-macros", defaultOptions)
+  }.checkRuns()
+
   @Test def runWithCompiler: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runWithCompiler")
     compileFilesInDir("tests/run-with-compiler", withCompilerOptions) +