Remove System.exit / __ScalaJSEnv.exitFunction

This has been added way back in the days (scala-js/scala-js#958) as a poor man's way to
support asynchronous testing.

Since then, testing has substantially matured. Notably a JSEnv is not
required anymore to be able to terminate automatically.

Therefore, there is no need anymore to support exiting in a platform
agnostic manner. Or if there is a need or such a thing, it should be
put in an external library with JS-style dynamic platform detection.

Unfortunately this makes the JSEnv test suite slightly more
complicated again (and basically reverts
6746cf3a20d2497bbc6c520666a47f7ec1cd28dd).

Author: gzm0

js-envs-test-kit/src/main/scala/org/scalajs/jsenv/test/ComTests.scala

@@ -12,7 +12,7 @@
 
 package org.scalajs.jsenv.test
 
-import org.junit.{Before, Test}
+import org.junit.{Before, Test, AssumptionViolatedException}
 import org.junit.Assume._
 
 import org.scalajs.jsenv._
@@ -48,10 +48,11 @@ private[test] class ComTests(config: JSEnvSuiteConfig) {
 
   @Test
   def jsExitsOnMessageTest: Unit = {
-    assumeTrue(config.supportsExit)
+    val exitStat = config.exitJSStatement.getOrElse(
+        throw new AssumptionViolatedException("JSEnv needs exitJSStatement"))
 
-    kit.withComRun("""
-      scalajsCom.init(function(msg) { __ScalaJSEnv.exitFunction(0); });
+    kit.withComRun(s"""
+      scalajsCom.init(function(msg) { $exitStat });
       for (var i = 0; i < 10; ++i)
         scalajsCom.send("msg: " + i);
       """) { run =>

js-envs-test-kit/src/main/scala/org/scalajs/jsenv/test/JSEnvSuiteConfig.scala

@@ -38,44 +38,44 @@ import scala.concurrent.duration._
  */
 final class JSEnvSuiteConfig private (
     val jsEnv: JSEnv,
-    val supportsExit: Boolean,
     val supportsCom: Boolean,
     val supportsTimeout: Boolean,
+    val exitJSStatement: Option[String],
     val awaitTimeout: FiniteDuration,
     val description: String
 ) {
   private def this(jsEnv: JSEnv) = this(
       jsEnv = jsEnv,
-      supportsExit = true,
       supportsCom = true,
       supportsTimeout = true,
+      exitJSStatement = None,
       awaitTimeout = 1.minute,
       description = jsEnv.name
   )
 
-  def withSupportsExit(supportsExit: Boolean): JSEnvSuiteConfig =
-    copy(supportsExit = supportsExit)
-
   def withSupportsCom(supportsCom: Boolean): JSEnvSuiteConfig =
     copy(supportsCom = supportsCom)
 
   def withSupportsTimeout(supportsTimeout: Boolean): JSEnvSuiteConfig =
     copy(supportsTimeout = supportsTimeout)
 
+  def withExitJSStatement(code: String): JSEnvSuiteConfig =
+    copy(exitJSStatement = Some(code))
+
   def withAwaitTimeout(awaitTimeout: FiniteDuration): JSEnvSuiteConfig =
     copy(awaitTimeout = awaitTimeout)
 
   def withDescription(description: String): JSEnvSuiteConfig =
     copy(description = description)
 
   private def copy(
-      supportsExit: Boolean = supportsExit,
       supportsCom: Boolean = supportsCom,
       supportsTimeout: Boolean = supportsTimeout,
+      exitJSStatement: Option[String] = exitJSStatement,
       awaitTimeout: FiniteDuration = awaitTimeout,
       description: String = description) = {
-    new JSEnvSuiteConfig(jsEnv, supportsExit, supportsCom,
-        supportsTimeout, awaitTimeout, description)
+    new JSEnvSuiteConfig(jsEnv, supportsCom, supportsTimeout,
+        exitJSStatement, awaitTimeout, description)
   }
 }
 

js-envs-test-kit/src/main/scala/org/scalajs/jsenv/test/RunTests.scala

@@ -13,7 +13,7 @@
 package org.scalajs.jsenv.test
 
 import org.junit.Assume._
-import org.junit.{Test, Before}
+import org.junit.{Test, Before, AssumptionViolatedException}
 
 import org.scalajs.io.VirtualBinaryFile
 import org.scalajs.jsenv._
@@ -88,9 +88,10 @@ private[test] class RunTests(config: JSEnvSuiteConfig, withCom: Boolean) {
 
   @Test
   def jsExitsTest: Unit = {
-    assumeTrue(config.supportsExit)
+    val exitStat = config.exitJSStatement.getOrElse(
+      throw new AssumptionViolatedException("JSEnv needs exitJSStatement"))
 
-    withRun("__ScalaJSEnv.exitFunction(0);") {
+    withRun(exitStat) {
       _.succeeds()
     }
   }

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

@@ -67,14 +67,10 @@ final class NodeJSEnv(config: NodeJSEnv.Config) extends JSEnv {
         NodeJSEnv.write(initFiles, input))
   }
 
-  private def initFiles: List[VirtualBinaryFile] = {
-    val base = List(NodeJSEnv.runtimeEnv)
-
-    config.sourceMap match {
-      case SourceMap.Disable           => base
-      case SourceMap.EnableIfAvailable => installSourceMapIfAvailable :: base
-      case SourceMap.Enable            => installSourceMap :: base
-    }
+  private def initFiles: List[VirtualBinaryFile] = config.sourceMap match {
+    case SourceMap.Disable           => Nil
+    case SourceMap.EnableIfAvailable => installSourceMapIfAvailable :: Nil
+    case SourceMap.Enable            => installSourceMap :: Nil
   }
 
   private def inputFiles(input: Input) = input match {
@@ -105,16 +101,6 @@ object NodeJSEnv {
         "require('source-map-support').install();")
   }
 
-  private lazy val runtimeEnv = {
-    MemVirtualBinaryFile.fromStringUTF8("scalaJSEnvInfo.js",
-        """
-          |__ScalaJSEnv = {
-          |  exitFunction: function(status) { process.exit(status); }
-          |};
-        """.stripMargin
-    )
-  }
-
   private def write(initFiles: List[VirtualBinaryFile], input: Input)(
       out: OutputStream): Unit = {
     val p = new PrintStream(out, false, "UTF8")

nodejs-env/src/test/scala/org/scalajs/jsenv/nodejs/NodeJSSuite.scala

@@ -17,4 +17,7 @@ import org.scalajs.jsenv.test._
 import org.junit.runner.RunWith
 
 @RunWith(classOf[JSEnvSuiteRunner])
-class NodeJSSuite extends JSEnvSuite(JSEnvSuiteConfig(new NodeJSEnv))
+class NodeJSSuite extends JSEnvSuite(
+  JSEnvSuiteConfig(new NodeJSEnv)
+    .withExitJSStatement("process.exit(0);")
+)