Execute tests/run/ tests with Scala.js.

Tests that are not supposed to pass (because they have Java
source files, use Java reflection, rely on NPEs being thrown,
use `scala.Enumeration`, etc.) are moved `tests/run-jvm-only/`.

Tests that did not work out of the box because of differences in
`toString` or `getClass` were changed to be portable.

Tests that require compliant semantics from the Scala.js linker
are moved to `run-with-compliant-semantics`.

The remaining tests are probably bugs, and are moved to
`run-pending-js`. They should be further investigated.

Author: sjrd

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

@@ -210,7 +210,10 @@ class CompilationTests {
       compileDir("tests/run-custom-args/Xmacro-settings/simple", defaultOptions.and("-Xmacro-settings:one,two,three")),
       compileDir("tests/run-custom-args/Xmacro-settings/compileTimeEnv", defaultOptions.and("-Xmacro-settings:a,b=1,c.b.a=x.y.z=1,myLogger.level=INFO")),
       compileFilesInDir("tests/run-deep-subtype", allowDeepSubtypes),
-      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init"))
+      compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init")),
+      compileFilesInDir("tests/run-with-compliant-semantics", defaultOptions.and("-Ysafe-init")),
+      compileFilesInDir("tests/run-pending-js", defaultOptions.and("-Ysafe-init")),
+      compileFilesInDir("tests/run-jvm-only", defaultOptions.and("-Ysafe-init")),
     ).checkRuns()
   }
 

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

@@ -739,7 +739,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) match {
+      else runMain(testSource.runClassPath, testSource.flags) 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)(implicit summaryReport: SummaryReporting): Status =
+  def runMain(classPath: String, flags: TestFlags)(implicit summaryReport: SummaryReporting): Status =
     monitor.runMain(classPath)
 
   /** Kill all processes */

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

@@ -72,7 +72,7 @@ object TestConfiguration {
   lazy val withTastyInspectorOptions =
     defaultOptions.withClasspath(withTastyInspectorClasspath).withRunClasspath(withTastyInspectorClasspath)
   lazy val scalaJSOptions =
-    defaultOptions.and("-scalajs").withClasspath(scalaJSClasspath)
+    defaultOptions.and("-scalajs").withClasspath(scalaJSClasspath).withRunClasspath(scalaJSClasspath)
   val allowDeepSubtypes = defaultOptions without "-Yno-deep-subtypes"
   val allowDoubleBindings = defaultOptions without "-Yno-double-bindings"
   val picklingOptions = defaultOptions and (

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

@@ -8,22 +8,26 @@ 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]) {
+  javacOptions: Array[String],
+  scalaJSCompliantSemantics: Boolean) {
 
   def and(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options ++ flags, javacOptions)
+    TestFlags(defaultClassPath, runClassPath, options ++ flags, javacOptions, scalaJSCompliantSemantics)
 
   def without(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options diff flags, javacOptions)
+    TestFlags(defaultClassPath, runClassPath, options diff flags, javacOptions, scalaJSCompliantSemantics)
 
   def withClasspath(classPath: String): TestFlags =
-    TestFlags(s"$defaultClassPath${JFile.pathSeparator}$classPath", runClassPath, options, javacOptions)
+    TestFlags(s"$defaultClassPath${JFile.pathSeparator}$classPath", runClassPath, options, javacOptions, scalaJSCompliantSemantics)
 
   def withRunClasspath(classPath: String): TestFlags =
-    TestFlags(defaultClassPath, s"$runClassPath${JFile.pathSeparator}$classPath", options, javacOptions)
+    TestFlags(defaultClassPath, s"$runClassPath${JFile.pathSeparator}$classPath", options, javacOptions, scalaJSCompliantSemantics)
 
   def withJavacOnlyOptions(flags: String*): TestFlags =
-    TestFlags(defaultClassPath, runClassPath, options, javacOptions ++ flags)
+    TestFlags(defaultClassPath, runClassPath, options, javacOptions ++ flags, scalaJSCompliantSemantics)
+
+  def withScalaJSCompliantSemantics(compliantSemantics: Boolean): TestFlags =
+    TestFlags(defaultClassPath, runClassPath, options, javacOptions, compliantSemantics)
 
   def all: Array[String] = Array("-classpath", defaultClassPath) ++ options
 
@@ -54,5 +58,6 @@ final case class TestFlags(
 }
 
 object TestFlags {
-  def apply(classPath: String, flags: Array[String]): TestFlags = TestFlags(classPath, classPath, flags, Array.empty)
+  def apply(classPath: String, flags: Array[String]): TestFlags =
+    TestFlags(classPath, classPath, flags, Array.empty, false)
 }

project/Build.scala

@@ -1228,6 +1228,11 @@ object Build {
     settings(
       commonNonBootstrappedSettings,
 
+      libraryDependencies ++= Seq(
+        "org.scala-js" %% "scalajs-linker" % scalaJSVersion % Test cross CrossVersion.for3Use2_13,
+        "org.scala-js" %% "scalajs-env-nodejs" % "1.3.0" % Test cross CrossVersion.for3Use2_13,
+      ),
+
       // Change the baseDirectory when running the tests
       Test / baseDirectory := baseDirectory.value.getParentFile,
 

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

@@ -0,0 +1,70 @@
+package dotty.tools.dotc
+
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext}
+
+import java.io.InputStream
+import java.nio.charset.StandardCharsets
+import java.nio.file.Path
+
+import dotty.tools.vulpix.*
+
+import org.scalajs.jsenv.*
+import org.scalajs.jsenv.nodejs.NodeJSEnv
+import org.scalajs.logging.*
+
+object JSRun:
+  def runJSCode(sjsCode: Path)(using ExecutionContext): Status =
+    val logger = new ScalaConsoleLogger(Level.Warn)
+
+    var stdoutStream: Option[InputStream] = None
+    var stderrStream: Option[InputStream] = None
+
+    val input = Input.Script(sjsCode) :: Nil
+    val config = RunConfig()
+      .withLogger(logger)
+      .withInheritOut(false)
+      .withInheritErr(false)
+      .withOnOutputStream { (out, err) =>
+        stdoutStream = out
+        stderrStream = err
+      }
+
+    val run = new NodeJSEnv().start(input, config)
+    try
+      val success = try {
+        Await.result(run.future, Duration.Inf)
+        true
+      } catch {
+        case _: Exception =>
+          false
+      }
+      val output = readStreamFully(stderrStream) + readStreamFully(stdoutStream)
+      if success then
+        Success(output)
+      else
+        Failure(output)
+    finally
+      run.close()
+  end runJSCode
+
+  private def readStreamFully(optStream: Option[InputStream]): String =
+    optStream match
+      case None =>
+        ""
+      case Some(stream) =>
+        try
+          val result = new java.io.ByteArrayOutputStream()
+          val buffer = new Array[Byte](1024)
+          while ({
+            val len = stream.read(buffer)
+            len >= 0 && {
+              result.write(buffer, 0, len)
+              true
+            }
+          }) ()
+          new String(result.toByteArray(), StandardCharsets.UTF_8)
+        finally
+          stream.close()
+  end readStreamFully
+end JSRun

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

@@ -32,6 +32,29 @@ class ScalaJSCompilationTests extends ParallelTesting {
       compileFilesInDir("tests/neg-scalajs", scalaJSOptions),
     ).checkExpectedErrors()
   }
+
+  // Run tests -----------------------------------------------------------------
+
+  override def runMain(classPath: String, flags: TestFlags)(implicit summaryReport: SummaryReporting): Status =
+    import scala.concurrent.ExecutionContext.Implicits.global
+
+    try
+      val sjsCode = ScalaJSLink.link(classPath, flags.scalaJSCompliantSemantics)
+      JSRun.runJSCode(sjsCode)
+    catch
+      case t: Exception =>
+        val writer = new java.io.StringWriter()
+        t.printStackTrace(new java.io.PrintWriter(writer))
+        Failure(writer.toString())
+  end runMain
+
+  @Test def runScalaJS: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("runScalaJS")
+    aggregateTests(
+      compileFilesInDir("tests/run", scalaJSOptions),
+      compileFilesInDir("tests/run-with-compliant-semantics", scalaJSOptions.withScalaJSCompliantSemantics(true)),
+    ).checkRuns()
+  }
 }
 
 object ScalaJSCompilationTests {

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

@@ -0,0 +1,58 @@
+package dotty.tools.dotc
+
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext}
+
+import java.io.File
+import java.nio.file.{Files, Path}
+
+import com.google.common.jimfs.Jimfs
+
+import org.scalajs.linker.*
+import org.scalajs.linker.interface.*
+import org.scalajs.logging.*
+
+object ScalaJSLink:
+  private val compliantSemantics: Semantics =
+    Semantics.Defaults
+      .withAsInstanceOfs(CheckedBehavior.Compliant)
+      .withArrayIndexOutOfBounds(CheckedBehavior.Compliant)
+      .withModuleInit(CheckedBehavior.Compliant)
+  end compliantSemantics
+
+  def link(classPath: String, useCompliantSemantics: Boolean)(using ExecutionContext): Path =
+    val cpEntries = classPath.split(File.pathSeparatorChar)
+
+    val logger = new ScalaConsoleLogger(Level.Warn)
+
+    val moduleInitializers = Seq(ModuleInitializer.mainMethodWithArgs(
+        "Test", "main", Nil))
+
+    val semantics = if useCompliantSemantics then compliantSemantics else Semantics.Defaults
+
+    val linkerConfig = StandardConfig()
+      .withCheckIR(true)
+      .withSourceMap(false)
+      .withBatchMode(true)
+      .withSemantics(semantics)
+
+    val linker = StandardImpl.linker(linkerConfig)
+
+    val dir = Jimfs.newFileSystem().getPath("tmp")
+    Files.createDirectory(dir)
+
+    val cache = StandardImpl.irFileCache().newCache
+    val result = PathIRContainer
+      .fromClasspath(cpEntries.toSeq.map(entry => new File(entry).toPath()))
+      .map(_._1)
+      .flatMap(cache.cached _)
+      .flatMap(linker.link(_, moduleInitializers, PathOutputDirectory(dir), logger))
+
+    val report = Await.result(result, Duration.Inf)
+
+    if (report.publicModules.size != 1)
+      throw new AssertionError(s"got other than 1 module: $report")
+
+    dir.resolve(report.publicModules.head.jsFileName)
+  end link
+end ScalaJSLink