Only skip reflection code on JS

- add basic support for `//> using target.platform jvm|scala-js` in Vulpix.
- if the directive is present, filter out files in compilation that dont match
  the test platform, also add a suffix to the expected check-file name.
- duplicate UnrollTestPlatformSpecific files for jvm and scala-js platforms,
  deleting the reflection code in scala-js version.
- remove directives from compilation tests not listened to by vulpix.

Author: bishabosha

compiler/test/dotty/tools/utils.scala

@@ -57,25 +57,54 @@ def assertThrows[T <: Throwable: ClassTag](p: T => Boolean)(body: => Any): Unit
     case NonFatal(other) => throw AssertionError(s"Wrong exception: expected ${implicitly[ClassTag[T]]} but was ${other.getClass.getName}").tap(_.addSuppressed(other))
 end assertThrows
 
+enum TestPlatform:
+  case JVM, ScalaJS
+  override def toString: String = this match
+    case JVM     => "jvm"
+    case ScalaJS => "scala-js"
+
+object TestPlatform:
+  def named(s: String): TestPlatform = s match
+    case "jvm"      => TestPlatform.JVM
+    case "scala-js" => TestPlatform.ScalaJS
+    case _          => throw IllegalArgumentException(s)
+
 /** Famous tool names in the ecosystem. Used for tool args in test files. */
 enum ToolName:
-  case Scala, Scalac, Java, Javac, ScalaJS, Test
+  case Scala, Scalac, Java, Javac, ScalaJS, Test, Target
 object ToolName:
   def named(s: String): ToolName = values.find(_.toString.equalsIgnoreCase(s)).getOrElse(throw IllegalArgumentException(s))
 
 type ToolArgs = Map[ToolName, List[String]]
+type PlatformFiles = Map[TestPlatform, List[String]]
 
 /** Take a prefix of each file, extract tool args, parse, and combine.
  *  Arg parsing respects quotation marks. Result is a map from ToolName to the combined tokens.
  */
 def toolArgsFor(files: List[JPath], charset: Charset = UTF_8): ToolArgs =
-  files.foldLeft(Map.empty[ToolName, List[String]]) { (res, path) =>
+  val (_, toolArgs) = platformAndToolArgsFor(files, charset)
+  toolArgs
+
+/** Take a prefix of each file, extract tool args, parse, and combine.
+ *  Arg parsing respects quotation marks. Result is a map from ToolName to the combined tokens.
+ * If the ToolName is Target, then also accumulate the file name associated with the given platform.
+ */
+def platformAndToolArgsFor(files: List[JPath], charset: Charset = UTF_8): (PlatformFiles, ToolArgs) =
+  files.foldLeft(Map.empty[TestPlatform, List[String]] -> Map.empty[ToolName, List[String]]) { (res, path) =>
     val toolargs = toolArgsParse(resource(Files.lines(path, charset))(_.limit(10).toScala(List)), Some(path.toString))
     toolargs.foldLeft(res) {
-      case (acc, (tool, args)) =>
+      case ((plat, acc), (tool, args)) =>
         val name = ToolName.named(tool)
         val tokens = CommandLineParser.tokenize(args)
-        acc.updatedWith(name)(v0 => v0.map(_ ++ tokens).orElse(Some(tokens)))
+
+        val plat1 = if name eq ToolName.Target then
+          val testPlatform = TestPlatform.named(tokens.head)
+          val fileName = path.toString
+          plat.updatedWith(testPlatform)(_.map(fileName :: _).orElse(Some(fileName :: Nil)))
+        else
+          plat
+
+        plat1 -> acc.updatedWith(name)(v0 => v0.map(_ ++ tokens).orElse(Some(tokens)))
     }
   }
 
@@ -94,6 +123,8 @@ private val toolArg = raw"(?://|/\*| \*) ?(?i:(${ToolName.values.mkString("|")})
 /** Directive to specify to vulpix the options to pass to Dotty */
 private val directiveOptionsArg = raw"//> using options (.*)".r.unanchored
 private val directiveJavacOptions = raw"//> using javacOpt (.*)".r.unanchored
+private val directiveTargetOptions = raw"//> using target.platform (jvm|scala-js)".r.unanchored
+private val directiveUnknown = raw"//> using (.*)".r.unanchored
 
 // Inspect the lines for compiler options of the form
 // `//> using options args`, `// scalajs: args`, `/* scalajs: args`, ` * scalajs: args` etc.
@@ -109,6 +140,8 @@ def toolArgsParse(lines: List[String], filename: Option[String]): List[(String,S
   lines.flatMap {
     case directiveOptionsArg(args) => List(("scalac", args))
     case directiveJavacOptions(args) => List(("javac", args))
+    case directiveTargetOptions(platform) => List(("target", platform))
+    case directiveUnknown(rest) => sys.error(s"Unknown directive: `//> using ${CommandLineParser.tokenize(rest).headOption.getOrElse("''")}`${filename.fold("")(f => s" in file $f")}")
     case _ => Nil
   }
 

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

@@ -60,6 +60,8 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   /** Contains a list of failed tests to run, if list is empty no tests will run */
   def failedTests: Option[List[String]]
 
+  protected def testPlatform: TestPlatform = TestPlatform.JVM
+
   /** A test source whose files or directory of files is to be compiled
    *  in a specific way defined by the `Test`
    */
@@ -343,7 +345,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             new JFile(f.getPath.replaceFirst("\\.(scala|java)$", ".check"))
         }
       case ts: SeparateCompilationSource =>
-        Option(new JFile(ts.dir.getPath + ".check"))
+        val platform =
+          if testSource.allToolArgs.getOrElse(ToolName.Target, Nil).nonEmpty then
+            s".$testPlatform"
+          else ""
+        Option(new JFile(ts.dir.getPath + platform + ".check"))
     }
   }
 
@@ -499,7 +505,8 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
       val files: Array[JFile] = files0.flatMap(flattenFiles)
 
-      val toolArgs = toolArgsFor(files.toList.map(_.toPath), getCharsetFromEncodingOpt(flags0))
+      val (platformFiles, toolArgs) =
+        platformAndToolArgsFor(files.toList.map(_.toPath), getCharsetFromEncodingOpt(flags0))
 
       val spec = raw"(\d+)(\+)?".r
       val testIsFiltered = toolArgs.get(ToolName.Test) match
@@ -557,7 +564,17 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         // If a test contains a Java file that cannot be parsed by Dotty's Java source parser, its
         // name must contain the string "JAVA_ONLY".
         val dottyFiles = files.filterNot(_.getName.contains("JAVA_ONLY")).map(_.getPath)
-        driver.process(allArgs ++ dottyFiles, reporter = reporter)
+
+        val dottyFiles0 =
+          if platformFiles.isEmpty then dottyFiles
+          else
+            val excludedFiles = platformFiles
+              .collect { case (plat, files) if plat != testPlatform => files }
+              .flatten
+              .toSet
+            dottyFiles.filterNot(excludedFiles)
+
+        driver.process(allArgs ++ dottyFiles0, reporter = reporter)
 
         // todo a better mechanism than ONLY. test: -scala-only?
         val javaFiles = files.filter(_.getName.endsWith(".java")).filterNot(_.getName.contains("SCALA_ONLY")).map(_.getPath)

sjs-compiler-tests/test/scala/dotty/tools/dotc/ScalaJSCompilationTests.scala

@@ -40,6 +40,8 @@ class ScalaJSCompilationTests extends ParallelTesting {
   override protected def shouldSkipTestSource(testSource: TestSource): Boolean =
     testSource.allToolArgs.get(ToolName.ScalaJS).exists(_.contains("--skip"))
 
+  override protected def testPlatform: TestPlatform = TestPlatform.ScalaJS
+
   override def runMain(classPath: String, toolArgs: ToolArgs)(implicit summaryReport: SummaryReporting): Status =
     import scala.concurrent.ExecutionContext.Implicits.global
 

tests/neg/16463.scala

@@ -1,4 +1,4 @@
-//> using scala "3.2.1"
+//!> using scala "3.2.1"
 
 import scala.compiletime.ops.int._
 

tests/neg/i19320.scala

@@ -1,7 +1,7 @@
-//> using scala "3.3.1"
-//> using dep org.http4s::http4s-ember-client:1.0.0-M40
-//> using dep org.http4s::http4s-ember-server:1.0.0-M40
-//> using dep org.http4s::http4s-dsl:1.0.0-M40
+//!> using scala "3.3.1"
+//!> using dep org.http4s::http4s-ember-client:1.0.0-M40
+//!> using dep org.http4s::http4s-ember-server:1.0.0-M40
+//!> using dep org.http4s::http4s-dsl:1.0.0-M40
 
 //import cats.effect.*
 //import cats.implicits.*

tests/neg/i21696.check

@@ -5,9 +5,9 @@
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  | Referencing `T` inside a quoted expression requires a `scala.quoted.Type[T]` to be in scope. 
+  | Referencing `T` inside a quoted expression requires a `scala.quoted.Type[T]` to be in scope.
   | Since Scala is subject to erasure at runtime, the type information will be missing during the execution of the code.
-  | `scala.quoted.Type[T]` is therefore needed to carry `T`'s type information into the quoted code. 
-  | Without an implicit `scala.quoted.Type[T]`, the type `T` cannot be properly referenced within the expression. 
+  | `scala.quoted.Type[T]` is therefore needed to carry `T`'s type information into the quoted code.
+  | Without an implicit `scala.quoted.Type[T]`, the type `T` cannot be properly referenced within the expression.
   | To resolve this, ensure that a `scala.quoted.Type[T]` is available, either through a context-bound or explicitly.
    ---------------------------------------------------------------------------------------------------------------------

tests/pos-custom-args/captures/i21347.scala

@@ -1,4 +1,4 @@
-//> using scala 3.6.0-RC1-bin-SNAPSHOT
+//!> using scala 3.6.0-RC1-bin-SNAPSHOT
 
 import language.experimental.captureChecking
 
@@ -8,4 +8,4 @@ def run[Cap^](f: Box[Cap]^{Cap^} => Unit): Box[Cap]^{Cap^} = ???
 
 def main() =
   val b = run(_ => ())
-  // val b = run[caps.CapSet](_ => ()) // this compiles
+  // val b = run[caps.CapSet](_ => ()) // this compiles

tests/run/unroll-caseclass-integration.check tests/run/unroll-caseclass-integration.jvm.check

@@ -1,12 +1,10 @@
-=== Unrolled Test V1 ===
 Assertion passed: found "cow1" + "true0"
 Assertion passed: found "cow2" + "true0"
 Assertion passed: found "cow1" + "true0"
 Assertion passed: found "cow2" + "true0"
 Assertion passed: found "cow1" + "true0"
 Assertion passed: found "cow2" + "true0"
 Assertion passed: found "hello31337" + "true0"
-=== Unrolled Test V2 ===
 Assertion passed: found "cow1true" + "0"
 Assertion passed: found "cow2true" + "0"
 Assertion passed: found "cow2false" + "0"
@@ -17,12 +15,7 @@ Assertion passed: found "cow1true" + "0"
 Assertion passed: found "cow2true" + "0"
 Assertion passed: found "cow2false" + "0"
 Assertion passed: found "hello31337false" + "0"
-=== Unrolled Test V3 ===
 Assertion passed: found "hello31337false12345"
-as expected, no constructor for Unrolled(s: String)
-public example.Unrolled(java.lang.String,int)
-public example.Unrolled(java.lang.String,int,boolean)
-public example.Unrolled(java.lang.String,int,boolean,long)
 Assertion passed: found "cow1true0"
 Assertion passed: found "cow2true0"
 Assertion passed: found "cow2false0"

tests/run/unroll-caseclass.check tests/run/unroll-caseclass-integration.scala-js.check

@@ -1,5 +1,4 @@
 //> using options -experimental
-// scalajs: --skip
 import unroll.*
 
 @main def Test: Unit =

tests/run/unroll-caseclass-integration/Test_4.scala

@@ -0,0 +1,9 @@
+//> using options -experimental
+//> using target.platform scala-js
+package unroll
+
+object UnrollTestPlatformSpecificV3{
+  def apply() = {
+    // do nothing for scala-js
+  }
+}

tests/run/unroll-caseclass-integration/UnrollTestPlatformSpecificJS_3.scala

@@ -1,5 +1,5 @@
 //> using options -experimental
-// scalajs: --skip
+//> using target.platform jvm
 package unroll
 
 object UnrollTestPlatformSpecificV3{