Use --skip and --compliant semantics flags inside source files.

Author: sjrd

compiler/test/dotty/tools/utils.scala

@@ -52,14 +52,16 @@ end assertThrows
 
 /** Famous tool names in the ecosystem. Used for tool args in test files. */
 enum ToolName:
-  case Scala, Scalac, Java, Javac, Test
+  case Scala, Scalac, Java, Javac, ScalaJS, Test
 object ToolName:
   def named(s: String): ToolName = values.find(_.toString.equalsIgnoreCase(s)).getOrElse(throw IllegalArgumentException(s))
 
+type ToolArgs = Map[ToolName, 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): Map[ToolName, List[String]] =
+def toolArgsFor(files: List[JPath], charset: Charset = UTF_8): ToolArgs =
   files.foldLeft(Map.empty[ToolName, List[String]]) { (res, path) =>
     val toolargs = toolArgsParse(resource(Files.lines(path, charset))(_.limit(10).toScala(List)))
     toolargs.foldLeft(res) {

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

@@ -96,6 +96,9 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         self.copy(flags = flags.without(flags1: _*))
     }
 
+    lazy val allToolArgs: ToolArgs =
+      toolArgsFor(sourceFiles.toList.map(_.toPath), getCharsetFromEncodingOpt(flags))
+
     /** Generate the instructions to redo the test from the command line */
     def buildInstructions(errors: Int, warnings: Int): String = {
       val sb = new StringBuilder
@@ -199,6 +202,9 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     def sourceFiles = compilationGroups.map(_._2).flatten.toArray
   }
 
+  protected def shouldSkipTestSource(testSource: TestSource): Boolean =
+    false
+
   private trait CompilationLogic { this: Test =>
     def suppressErrors = false
 
@@ -344,13 +350,15 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     /** All testSources left after filtering out */
     private val filteredSources =
-      if (testFilter.isEmpty) testSources
-      else testSources.filter {
-        case JointCompilationSource(_, files, _, _, _, _) =>
-          testFilter.exists(filter => files.exists(file => file.getPath.contains(filter)))
-        case SeparateCompilationSource(_, dir, _, _) =>
-          testFilter.exists(dir.getPath.contains)
-      }
+      val filteredByName =
+        if (testFilter.isEmpty) testSources
+        else testSources.filter {
+          case JointCompilationSource(_, files, _, _, _, _) =>
+            testFilter.exists(filter => files.exists(file => file.getPath.contains(filter)))
+          case SeparateCompilationSource(_, dir, _, _) =>
+            testFilter.exists(dir.getPath.contains)
+        }
+      filteredByName.filterNot(shouldSkipTestSource(_))
 
     /** Total amount of test sources being compiled by this test */
     val sourceCount = filteredSources.length
@@ -739,7 +747,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     private def verifyOutput(checkFile: Option[JFile], dir: JFile, testSource: TestSource, warnings: Int, reporters: Seq[TestReporter], logger: LoggedRunnable) = {
       if (Properties.testsNoRun) addNoRunWarning()
-      else runMain(testSource.runClassPath, testSource.flags) match {
+      else runMain(testSource.runClassPath, testSource.allToolArgs) match {
         case Success(output) => checkFile match {
           case Some(file) if file.exists => diffTest(testSource, file, output.linesIterator.toList, reporters, logger)
           case _ =>

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

@@ -48,7 +48,7 @@ trait RunnerOrchestration {
   def safeMode: Boolean
 
   /** Running a `Test` class's main method from the specified `dir` */
-  def runMain(classPath: String, flags: TestFlags)(implicit summaryReport: SummaryReporting): Status =
+  def runMain(classPath: String, toolArgs: ToolArgs)(implicit summaryReport: SummaryReporting): Status =
     monitor.runMain(classPath)
 
   /** Kill all processes */

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

@@ -8,26 +8,22 @@ final case class TestFlags(
   defaultClassPath: String,
   runClassPath: String, // class path that is used when running `run` tests (not compiling)
   options: Array[String],
-  javacOptions: Array[String],
-  scalaJSCompliantSemantics: Boolean) {
+  javacOptions: Array[String]) {
 
   def and(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options ++ flags, javacOptions, scalaJSCompliantSemantics)
+    TestFlags(defaultClassPath, runClassPath, options ++ flags, javacOptions)
 
   def without(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options diff flags, javacOptions, scalaJSCompliantSemantics)
+    TestFlags(defaultClassPath, runClassPath, options diff flags, javacOptions)
 
   def withClasspath(classPath: String): TestFlags =
-    TestFlags(s"$defaultClassPath${JFile.pathSeparator}$classPath", runClassPath, options, javacOptions, scalaJSCompliantSemantics)
+    TestFlags(s"$defaultClassPath${JFile.pathSeparator}$classPath", runClassPath, options, javacOptions)
 
   def withRunClasspath(classPath: String): TestFlags =
-    TestFlags(defaultClassPath, s"$runClassPath${JFile.pathSeparator}$classPath", options, javacOptions, scalaJSCompliantSemantics)
+    TestFlags(defaultClassPath, s"$runClassPath${JFile.pathSeparator}$classPath", options, javacOptions)
 
   def withJavacOnlyOptions(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options, javacOptions ++ flags, scalaJSCompliantSemantics)
-
-  def withScalaJSCompliantSemantics(compliantSemantics: Boolean): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options, javacOptions, compliantSemantics)
+    TestFlags(defaultClassPath, runClassPath, options, javacOptions ++ flags)
 
   def all: Array[String] = Array("-classpath", defaultClassPath) ++ options
 
@@ -58,6 +54,5 @@ final case class TestFlags(
 }
 
 object TestFlags {
-  def apply(classPath: String, flags: Array[String]): TestFlags =
-    TestFlags(classPath, classPath, flags, Array.empty, false)
+  def apply(classPath: String, flags: Array[String]): TestFlags = TestFlags(classPath, classPath, flags, Array.empty)
 }

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

@@ -35,11 +35,17 @@ class ScalaJSCompilationTests extends ParallelTesting {
 
   // Run tests -----------------------------------------------------------------
 
-  override def runMain(classPath: String, flags: TestFlags)(implicit summaryReport: SummaryReporting): Status =
+  override protected def shouldSkipTestSource(testSource: TestSource): Boolean =
+    testSource.allToolArgs.get(ToolName.ScalaJS).exists(_.contains("--skip"))
+
+  override def runMain(classPath: String, toolArgs: ToolArgs)(implicit summaryReport: SummaryReporting): Status =
     import scala.concurrent.ExecutionContext.Implicits.global
 
+    val scalaJSOptions = toolArgs.getOrElse(ToolName.ScalaJS, Nil)
+
     try
-      val sjsCode = ScalaJSLink.link(classPath, flags.scalaJSCompliantSemantics)
+      val useCompliantSemantics = scalaJSOptions.contains("--compliant-semantics")
+      val sjsCode = ScalaJSLink.link(classPath, useCompliantSemantics)
       JSRun.runJSCode(sjsCode)
     catch
       case t: Exception =>
@@ -52,7 +58,9 @@ class ScalaJSCompilationTests extends ParallelTesting {
     implicit val testGroup: TestGroup = TestGroup("runScalaJS")
     aggregateTests(
       compileFilesInDir("tests/run", scalaJSOptions),
-      compileFilesInDir("tests/run-with-compliant-semantics", scalaJSOptions.withScalaJSCompliantSemantics(true)),
+      compileFilesInDir("tests/run-with-compliant-semantics", scalaJSOptions),
+      compileFilesInDir("tests/run-pending-js", scalaJSOptions),
+      compileFilesInDir("tests/run-jvm-only", scalaJSOptions),
     ).checkRuns()
   }
 }

tests/run-jvm-only/10838/Test.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test {
   def main(args: Array[String]): Unit = {
     val a = new A

tests/run-jvm-only/Course-2002-01.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 01
 //############################################################################

tests/run-jvm-only/Course-2002-02.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 02
 //############################################################################

tests/run-jvm-only/Course-2002-03.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 03
 //############################################################################

tests/run-jvm-only/Course-2002-04.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 04
 //############################################################################

tests/run-jvm-only/Course-2002-05.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 05
 //############################################################################

tests/run-jvm-only/Course-2002-06.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 06
 //############################################################################

tests/run-jvm-only/Course-2002-07.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 07
 //############################################################################

tests/run-jvm-only/Course-2002-08.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 08
 //############################################################################

tests/run-jvm-only/Course-2002-09.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 09
 //############################################################################

tests/run-jvm-only/Course-2002-10.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 10
 //############################################################################

tests/run-jvm-only/Course-2002-13.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Programmation IV - 2002 - Week 13
 //############################################################################

tests/run-jvm-only/arrays-from-java/Test_2.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test {
   def main(args: Array[String]): Unit =
     C_2.test()

tests/run-jvm-only/assert-stack.scala

@@ -1,4 +1,4 @@
-
+// scalajs: --skip
 
 object Test {
 

tests/run-jvm-only/beans/Test_4.scala

@@ -1,4 +1,6 @@
+// scalajs: --skip
+
 object Test:
   def main(args: Array[String]) =
     val a = JavaTest().run()
-    println(a.mutableOneWithLongName)
+    println(a.mutableOneWithLongName)

tests/run-jvm-only/capturing.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 class MT(sf: MT => String) {
   // `s` is retained as a field, but `sf` should not be.
   val s = sf(this)

tests/run-jvm-only/case-class-serializable.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 case class Foo(s: String)
 
 object Test {

tests/run-jvm-only/classof.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 class ValueClass(val i: Integer) extends AnyVal
 class SomeClass
 

tests/run-jvm-only/deadlock.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 // from https://github.com/rickynils/scalacheck/issues/290
 import scala.concurrent.*
 import scala.concurrent.duration.*

tests/run-jvm-only/defaults-serizaliable-with-forwarders.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import java.io.{ByteArrayInputStream, ByteArrayOutputStream, ObjectInputStream, ObjectOutputStream}
 
 trait T1 extends Serializable {

tests/run-jvm-only/enum-efficient-collections.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 enum Day extends java.lang.Enum[Day] {
   case MONDAY, TUESDAY, SATURDAY, WEDNESDAY
 }

tests/run-jvm-only/enum-java/Test.java

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 public class Test {
   public static void log(String x) { System.out.println(x); }
   public static void check(Boolean p, String message) {

tests/run-jvm-only/enum-values.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import reflect.Selectable.reflectiveSelectable
 import deriving.Mirror
 

tests/run-jvm-only/enums-serialization-compat.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import java.io.*
 import scala.util.Using
 

tests/run-jvm-only/enums.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 //############################################################################
 // Enumerations
 //############################################################################

tests/run-jvm-only/erased-inline-vals.scala

@@ -1,3 +1,4 @@
+// scalajs: --skip
 
 abstract class A:
   def x: Int

tests/run-jvm-only/exceptions-2.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 /*
  * Try exception handling and finally blocks.
  */

tests/run-jvm-only/exceptions-nest.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test extends App {
 
   println(test1)

tests/run-jvm-only/forwarder-java-package-private/Test_2.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 package scalapackage:
   object Foo extends javapackage.Base_1
 end scalapackage

tests/run-jvm-only/forwarder.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 class Foo
 object Foo extends Bar
 

tests/run-jvm-only/future-flatmap-exec-count.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import scala.concurrent.*
 import java.util.concurrent.atomic.AtomicInteger
 

tests/run-jvm-only/getclass.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 class ValueClass(val i: Integer) extends AnyVal
 class SomeClass
 

tests/run-jvm-only/hashhash.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test {
   def confirmSame(x: Any)       = assert(x.## == x.hashCode, "%s.## != %s.hashCode".format(x, x))
   def confirmDifferent(x: Any)  = assert(x.## != x.hashCode, "%s.## == %s.hashCode (but should not)".format(x, x))

tests/run-jvm-only/i10884/Test_2.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Exporter:
   export JavaExporter_1._
 

tests/run-jvm-only/i11114.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 @main def Test() =
   println((1, 1).getClass)
   println(Tuple2.apply(1, 1).getClass)

tests/run-jvm-only/i11367.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 trait NoOuter:
   val outerFields = getClass.getDeclaredFields.filter(_.getName.contains("$outer"))
   if outerFields.nonEmpty then println(s"$getClass has outer fields")

tests/run-jvm-only/i11486/Test_2.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 import java.lang.reflect.Executable
 
 case class Tested(foo: Int, bar: String, baz: Double):

tests/run-jvm-only/i12086/Test_3.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test {
   def main(args: Array[String]): Unit = {
     val c = new C

tests/run-jvm-only/i12204/Test_3.scala

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 object Test {
   def main(args: Array[String]): Unit = {
     B_2.test()

tests/run-jvm-only/i12753/Test.java

@@ -1,3 +1,5 @@
+// scalajs: --skip
+
 public class Test {
   public static void s(Object s) {
     System.out.println(s);