Fix scala-js/scala-js#2175: Add support for ECMAScript 2015 modules.

This is a port of b744d12e0c6d8af74960e0ce5071c8e0011249a5.

This commit adds a third `ModuleKind` for ES modules, namely
`ModuleKind.ESModule`. When emitting an ES module, `@JSImport`s
and `@JSExportTopLevel`s straightforwardly map to ES `import` and
`export` clauses, respectively.

At the moment, imports are always implemented using a namespace
import, then selecting fields inside the namespace. This is
suboptimal because it can prevent advanced DCE across ES modules.
Improving on this is left for future work.

A new `Input.ESModulesToLoad` instructs a JSEnv to load files as
ES modules.

The Node.js-based environment, however, will only *actually*
interpret the files as ES modules if their name ends with `.mjs`.
This happens because of how Node.js itself identifies ES modules
as of version 10.x, although it is still experimental, so that
could change in the future. `.js` files will be loaded as
CommonJS modules instead.

Although setting `scalaJSLinkerConfig.moduleKind` to
`ModuleKind.ESModule` is enough for the Scala.js linker to emit a
valid ES module, two additional settings are required to *run* or
*test* using Node.js:

    artifactPath in (proj, Compile, fastOptJS) :=
      (crossTarget in (proj, Compile)).value / "somename.mjs"

    jsEnv := {
      new org.scalajs.jsenv.NodeJSEnv(
          org.scalajs.jsenv.NODEJSEnv.Config()
            .withArguments(List("--experimental-modules"))
      )
    }

The first setting is necessary to give the `.mjs` extension to the
file produced by Scala.js, which in turn is necessary for Node.js
to accept it as an ES module.

The second setting will be necessary until Node.js declares its
support for ES module as non-experimental.

The version of the Closure Compiler that we use does not support
ES modules yet, so we deactivate GCC when emitting an ES module.

At this point, the emission of ES modules can be considered stable,
but the support in `NodeJSEnv` is experimental (since the support
of ES modules in Node.js is itself experimental).

Running the full test suite with ES modules requires Node.js 10.2.0
or later. It has been tested with v10.12.0.

Author: sjrd

js-envs/src/main/scala/org/scalajs/jsenv/Input.scala

@@ -29,6 +29,16 @@ object Input {
   /** All files are to be loaded as scripts into the global scope in the order given. */
   final case class ScriptsToLoad(scripts: List[VirtualBinaryFile]) extends Input
 
+  /** All files are to be loaded as ES modules, in the given order.
+   *
+   *  Some environments may not be able to execute several ES modules in a
+   *  deterministic order. If that is the case, they must reject an
+   *  `ESModulesToLoad` input if the `modules` argument has more than one
+   *  element.
+   */
+  final case class ESModulesToLoad(modules: List[VirtualBinaryFile])
+      extends Input
+
   /** All files are to be loaded as CommonJS modules, in the given order. */
   final case class CommonJSModulesToLoad(modules: List[VirtualBinaryFile])
       extends Input

nodejs-env/src/main/scala/org/scalajs/jsenv/nodejs/NodeJSEnv.scala

@@ -49,7 +49,8 @@ final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
 
   private def validateInput(input: Input): Unit = {
     input match {
-      case _:Input.ScriptsToLoad | _:Input.CommonJSModulesToLoad =>
+      case _:Input.ScriptsToLoad | _:Input.ESModulesToLoad |
+          _:Input.CommonJSModulesToLoad =>
         // ok
       case _ =>
         throw new UnsupportedInputException(input)
@@ -164,6 +165,34 @@ object NodeJSEnv {
         case Input.CommonJSModulesToLoad(modules) =>
           for (module <- modules)
             writeRequire(module)
+
+        case Input.ESModulesToLoad(modules) =>
+          if (modules.nonEmpty) {
+            val uris = modules.map {
+              case module: FileVirtualBinaryFile =>
+                module.file.toURI
+              case module =>
+                tmpFile(module.path, module.inputStream).toURI
+            }
+
+            val imports = uris.map { uri =>
+              s"""import("${escapeJS(uri.toASCIIString)}")"""
+            }
+            val importChain = imports.reduceLeft { (prev, imprt) =>
+              s"""$prev.then(_ => $imprt)"""
+            }
+
+            val importerFileContent = {
+              s"""
+                |$importChain.catch(e => {
+                |  console.error(e);
+                |  process.exit(1);
+                |});
+              """.stripMargin
+            }
+            val f = tmpFile("importer.js", importerFileContent)
+            p.println(s"""require("${escapeJS(f.getAbsolutePath)}");""")
+          }
       }
     } finally {
       p.close()
@@ -192,6 +221,17 @@ object NodeJSEnv {
     new String(baos.toByteArray(), StandardCharsets.UTF_8)
   }
 
+  private def tmpFile(path: String, content: String): File = {
+    import java.nio.file.{Files, StandardOpenOption}
+
+    val f = createTmpFile(path)
+    val contentList = new java.util.ArrayList[String]()
+    contentList.add(content)
+    Files.write(f.toPath(), contentList, StandardCharsets.UTF_8,
+        StandardOpenOption.TRUNCATE_EXISTING)
+    f
+  }
+
   private def tmpFile(path: String, content: InputStream): File = {
     import java.nio.file.{Files, StandardCopyOption}