Add infrastructure to run the JUnit tests of upstream Scala.js.

And run one test for now: `compiler/IntTest.scala`.

Author: sjrd

.drone.yml

@@ -31,7 +31,7 @@ pipeline:
     image: lampepfl/dotty:2019-04-22
     commands:
       - cp -R . /tmp/2/ && cd /tmp/2/
-      - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/test; dotty-semanticdb/compile; dotty-semanticdb/test:compile;sjsSandbox/run;sjsSandbox/test"
+      - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/test; dotty-semanticdb/compile; dotty-semanticdb/test:compile;sjsSandbox/run;sjsSandbox/test;sjsJUnitTests/test"
       - ./project/scripts/bootstrapCmdTests
 
   community_build:

build.sbt

@@ -7,6 +7,7 @@ val `dotty-compiler` = Build.`dotty-compiler`
 val `dotty-compiler-bootstrapped` = Build.`dotty-compiler-bootstrapped`
 val `dotty-library` = Build.`dotty-library`
 val `dotty-library-bootstrapped` = Build.`dotty-library-bootstrapped`
+val `dotty-library-bootstrappedJS` = Build.`dotty-library-bootstrappedJS`
 val `dotty-sbt-bridge` = Build.`dotty-sbt-bridge`
 val `dotty-sbt-bridge-tests` = Build.`dotty-sbt-bridge-tests`
 val `dotty-language-server` = Build.`dotty-language-server`
@@ -23,6 +24,7 @@ val `dist-bootstrapped` = Build.`dist-bootstrapped`
 val `community-build` = Build.`community-build`
 
 val sjsSandbox = Build.sjsSandbox
+val sjsJUnitTests = Build.sjsJUnitTests
 
 val `sbt-dotty` = Build.`sbt-dotty`
 val `vscode-dotty` = Build.`vscode-dotty`

project/Build.scala

@@ -28,6 +28,35 @@ import sbtbuildinfo.BuildInfoPlugin.autoImport._
 
 import scala.util.Properties.isJavaAtLeast
 
+object MyScalaJSPlugin extends AutoPlugin {
+  import Build._
+
+  override def requires: Plugins = ScalaJSPlugin
+
+  override def projectSettings: Seq[Setting[_]] = Def.settings(
+    commonBootstrappedSettings,
+
+    /* Remove the Scala.js compiler plugin for scalac, and enable the
+     * Scala.js back-end of dotty instead.
+     */
+    libraryDependencies := {
+      val deps = libraryDependencies.value
+      deps.filterNot(_.name.startsWith("scalajs-compiler")).map(_.withDottyCompat(scalaVersion.value))
+    },
+    scalacOptions += "-scalajs",
+
+    // Replace the JVM JUnit dependency by the Scala.js one
+    libraryDependencies ~= {
+      _.filter(!_.name.startsWith("junit-interface"))
+    },
+    libraryDependencies +=
+      "org.scala-js" % "scalajs-junit-test-runtime_2.12" % scalaJSVersion  % "test",
+
+    // Typecheck the Scala.js IR found on the classpath
+    scalaJSLinkerConfig ~= (_.withCheckIR(true)),
+  )
+}
+
 object Build {
   val scalacVersion = "2.12.8"
   val referenceVersion = "0.14.0-RC1"
@@ -101,6 +130,8 @@ object Build {
   val ideTestsCompilerArguments = taskKey[Seq[String]]("Compiler arguments to use in IDE tests")
   val ideTestsDependencyClasspath = taskKey[Seq[File]]("Dependency classpath to use in IDE tests")
 
+  val fetchScalaJSSource = taskKey[File]("Fetch the sources of Scala.js")
+
   lazy val SourceDeps = config("sourcedeps")
 
   // Settings shared by the build (scoped in ThisBuild). Used in build.sbt
@@ -714,6 +745,22 @@ object Build {
     case Bootstrapped => `dotty-library-bootstrapped`
   }
 
+  lazy val `dotty-library-bootstrappedJS`: Project = project.in(file("library-js")).
+    asDottyLibrary(Bootstrapped).
+    enablePlugins(MyScalaJSPlugin).
+    settings(
+      // TODO Compile more (enventually all) of the library
+      /*unmanagedSourceDirectories in Compile :=
+        (unmanagedSourceDirectories in (`dotty-library-bootstrapped`, Compile)).value,*/
+      sources in Compile := {
+        val baseDir = (baseDirectory in (`dotty-library-bootstrapped`, Compile)).value
+        Seq(
+          baseDir / "src/scala/forceInline.scala",
+          baseDir / "src-3.x/dotty/DottyPredef.scala",
+        )
+      },
+    )
+
   lazy val `dotty-sbt-bridge` = project.in(file("sbt-bridge/src")).
     // We cannot depend on any bootstrapped project to compile the bridge, since the
     // bridge is needed to compile these projects.
@@ -819,36 +866,95 @@ object Build {
    *  useful, as that would not provide the linker and JS runners.
    */
   lazy val sjsSandbox = project.in(file("sandbox/scalajs")).
-    enablePlugins(ScalaJSPlugin).
-    dependsOn(dottyLibrary(Bootstrapped)).
-    settings(commonBootstrappedSettings).
+    enablePlugins(MyScalaJSPlugin).
+    dependsOn(`dotty-library-bootstrappedJS`).
     settings(
-      /* Remove the Scala.js compiler plugin for scalac, and enable the
-       * Scala.js back-end of dotty instead.
-       */
-      libraryDependencies := {
-        val deps = libraryDependencies.value
-        deps.filterNot(_.name.startsWith("scalajs-compiler")).map(_.withDottyCompat(scalaVersion.value))
-      },
-      scalacOptions += "-scalajs",
+      scalaJSUseMainModuleInitializer := true,
+    )
 
-      // Replace the JVM JUnit dependency by the Scala.js one
-      libraryDependencies ~= {
-        _.filter(!_.name.startsWith("junit-interface"))
+  lazy val sjsJUnitTests = project.in(file("tests/sjs-junit")).
+    enablePlugins(MyScalaJSPlugin).
+    dependsOn(`dotty-library-bootstrappedJS`).
+    settings(
+      scalacOptions --= Seq("-Xfatal-warnings", "-deprecation"),
+
+      sourceDirectory in fetchScalaJSSource := target.value / s"scala-js-src-$scalaJSVersion",
+
+      fetchScalaJSSource := {
+        import org.eclipse.jgit.api._
+
+        val s = streams.value
+        val ver = scalaJSVersion
+        val trgDir = (sourceDirectory in fetchScalaJSSource).value
+
+        if (!trgDir.exists) {
+          s.log.info(s"Fetching Scala.js source version $ver")
+          IO.createDirectory(trgDir)
+          new CloneCommand()
+            .setDirectory(trgDir)
+            .setURI("https://github.com/scala-js/scala-js.git")
+            .call()
+        }
+
+        // Checkout proper ref. We do this anyway so we fail if something is wrong
+        val git = Git.open(trgDir)
+        s.log.info(s"Checking out Scala.js source version $ver")
+        git.checkout().setName(s"v$ver").call()
+
+        trgDir
       },
+
+      // We need JUnit in the Compile configuration
       libraryDependencies +=
-        "org.scala-js" % "scalajs-junit-test-runtime_2.12" % scalaJSVersion  % "test",
+        "org.scala-js" % "scalajs-junit-test-runtime_2.12" % scalaJSVersion,
+
+      sourceGenerators in Compile += Def.task {
+        import org.scalajs.linker.CheckedBehavior
 
-      // The main class cannot be found automatically due to the empty inc.Analysis
-      mainClass in Compile := Some("hello.HelloWorld"),
+        val stage = scalaJSStage.value
 
-      scalaJSUseMainModuleInitializer := true,
+        val linkerConfig = stage match {
+          case FastOptStage => (scalaJSLinkerConfig in (Compile, fastOptJS)).value
+          case FullOptStage => (scalaJSLinkerConfig in (Compile, fullOptJS)).value
+        }
 
-      /* Debug-friendly Scala.js optimizer options.
-       * In particular, typecheck the Scala.js IR found on the classpath.
-       */
-      scalaJSLinkerConfig ~= {
-        _.withCheckIR(true).withParallel(false)
+        val moduleKind = linkerConfig.moduleKind
+        val sems = linkerConfig.semantics
+
+        ConstantHolderGenerator.generate(
+            (sourceManaged in Compile).value,
+            "org.scalajs.testsuite.utils.BuildInfo",
+            "scalaVersion" -> scalaVersion.value,
+            "hasSourceMaps" -> false, //MyScalaJSPlugin.wantSourceMaps.value,
+            "isNoModule" -> (moduleKind == ModuleKind.NoModule),
+            "isESModule" -> (moduleKind == ModuleKind.ESModule),
+            "isCommonJSModule" -> (moduleKind == ModuleKind.CommonJSModule),
+            "isFullOpt" -> (stage == FullOptStage),
+            "compliantAsInstanceOfs" -> (sems.asInstanceOfs == CheckedBehavior.Compliant),
+            "compliantArrayIndexOutOfBounds" -> (sems.arrayIndexOutOfBounds == CheckedBehavior.Compliant),
+            "compliantModuleInit" -> (sems.moduleInit == CheckedBehavior.Compliant),
+            "strictFloats" -> sems.strictFloats,
+            "productionMode" -> sems.productionMode,
+            "es2015" -> linkerConfig.esFeatures.useECMAScript2015,
+        )
+      }.taskValue,
+
+      managedSources in Compile ++= {
+        val dir = fetchScalaJSSource.value / "test-suite/js/src/main/scala"
+        val filter = (
+          ("*.scala": FileFilter)
+            -- "Typechecking*.scala"
+            -- "NonNativeTypeTestSeparateRun.scala"
+        )
+        (dir ** filter).get
+      },
+
+      managedSources in Test ++= {
+        val dir = fetchScalaJSSource.value / "test-suite"
+        (
+          (dir / "shared/src/test/scala/org/scalajs/testsuite/compiler" ** "IntTest.scala").get
+          ++ (dir / "shared/src/test/scala/org/scalajs/testsuite/utils" ** "*.scala").get
+        )
       }
     )
 

project/ConstantHolderGenerator.scala

@@ -0,0 +1,44 @@
+import scala.annotation.tailrec
+
+import sbt._
+
+import org.scalajs.ir.ScalaJSVersions
+
+object ConstantHolderGenerator {
+  /** Generate a *.scala file that contains the given values as literals. */
+  def generate(dir: File, fqn: String, values: (String, Any)*): Seq[File] = {
+    val (fullPkg@(_ :+ pkg)) :+ objectName = fqn.split('.').toSeq
+
+    val out = dir / (objectName + ".scala")
+
+    val defs = for {
+      (name, value) <- values
+    } yield {
+      s"val $name = ${literal(value)}"
+    }
+
+    val scalaCode =
+      s"""
+      package ${fullPkg.mkString(".")}
+
+      private[$pkg] object $objectName {
+        ${defs.mkString("\n")}
+      }
+      """
+
+    IO.write(out, scalaCode)
+
+    Seq(out)
+  }
+
+  @tailrec
+  private final def literal(v: Any): String = v match {
+    case s: String  => "raw\"\"\"" + s + "\"\"\""
+    case b: Boolean => b.toString
+    case f: File    => literal(f.getAbsolutePath)
+
+    case _ =>
+      throw new IllegalArgumentException(
+          "Unsupported value type: " + v.getClass)
+  }
+}