Allow to cross build with Scala 2.13 (#6)

* Allow for cross building with Scala 2.11 and 2.13

* Get rid of Scala 2.13 deprecations

* Allow to compile with Scala 2.11

* Don't cross build for Scala 2.11

* Move scripted tests back to original location

* Fix running scripted tests

* Update CI to test cross building

* Revert spourious change

Author: WojciechMazur

.github/workflows/CI.yml

@@ -18,6 +18,6 @@ jobs:
       - name: Test
         run: >
          sbt 'set cli/scalaNativeVersion := "${{matrix.SN}}"'
-         cli/test
-         cli/scripted
+         +cli/test
+         +cliScriptedTests/scripted
         shell: bash

build.sbt

@@ -1,4 +1,16 @@
-val crossScalaNative212 = Seq("2.12.13", "2.12.14", "2.12.15")
+val crossScalaVersions212 = (13 to 15).map(v => s"2.12.$v")
+val crossScalaVersions213 = (4 to 7).map(v => s"2.13.$v")
+val latestsScalaVersions =
+  Seq(crossScalaVersions212.last, crossScalaVersions213.last)
+
+def scalaReleasesForBinaryVersion(v: String): Seq[String] = v match {
+  case "2.12" => crossScalaVersions212
+  case "2.13" => crossScalaVersions213
+  case ver =>
+    throw new IllegalArgumentException(
+      s"Unsupported binary scala version `${ver}`"
+    )
+}
 
 val scalaNativeVersion =
   settingKey[String]("Version of Scala Native for which to build to CLI")
@@ -8,9 +20,10 @@ val cliAssemblyJarName = settingKey[String]("Name of created assembly jar")
 inThisBuild(
   Def.settings(
     organization := "org.scala-native",
-    scalaVersion := crossScalaNative212.last,
-    scalaNativeVersion := "0.4.0",
-    version := scalaNativeVersion.value
+    scalaNativeVersion := "0.4.2",
+    version := scalaNativeVersion.value,
+    scalaVersion := crossScalaVersions212.last,
+    crossScalaVersions := latestsScalaVersions
   )
 )
 val cliPackLibJars =
@@ -19,9 +32,16 @@ val cliPack = taskKey[File]("Pack the CLI for the current configuration")
 
 lazy val cli = project
   .in(file("cli"))
-  .enablePlugins(BuildInfoPlugin, ScriptedPlugin)
+  .enablePlugins(BuildInfoPlugin)
   .settings(
     name := "scala-native-cli",
+    crossScalaVersions := {
+      scalaNativeVersion.value match {
+        // No Scala 2.13 artifacts until 0.4.2
+        case "0.4.0" | "0.4.1" => Seq(crossScalaVersions212.last)
+        case _                 => latestsScalaVersions
+      }
+    },
     Compile / run / mainClass :=
       Some("scala.scalanative.cli.ScalaNativeCli"),
     scalacOptions += "-Ywarn-unused:imports",
@@ -38,35 +58,48 @@ lazy val cli = project
     cliAssemblyJarName := s"${normalizedName.value}-assembly_${scalaBinaryVersion.value}-${scalaNativeVersion.value}.jar",
     assembly / assemblyJarName := cliAssemblyJarName.value,
     assembly / mainClass := (Compile / run / mainClass).value,
+    cliPackSettings
+  )
+
+lazy val cliScriptedTests = project
+  .in(file("cliScriptedTests"))
+  .enablePlugins(ScriptedPlugin)
+  .settings(
+    sbtTestDirectory := (cli / sourceDirectory).value / "sbt-test",
+    scalaVersion := crossScalaVersions212.last,
     scriptedLaunchOpts ++= {
-      val jarName = cliAssemblyJarName.value
-      val cliPath = (Compile / crossTarget).value / jarName
+      val jarName = (cli / cliAssemblyJarName).value
+      val cliPath = (cli / Compile / crossTarget).value / jarName
+      val packDir = (cli / cliPack / crossTarget).value
       Seq(
         "-Xmx1024M",
-        "-Dplugin.version=" + scalaNativeVersion.value,
+        "-Dplugin.version=" + (cli / scalaNativeVersion).value,
+        "-Dscala.version=" + (cli / scalaVersion).value,
         "-Dscala-native-cli=" + cliPath,
-        "-Dscala-native-cli-pack=" + (cliPack / crossTarget).value
+        "-Dscala-native-cli-pack=" + packDir
       )
     },
     scriptedBufferLog := false,
     scriptedDependencies := {
       scriptedDependencies
-        .dependsOn(assembly, cliPack)
+        .dependsOn(
+          cli / assembly,
+          cli / cliPack
+        )
         .value
-    },
-    cliPackSettings
+    }
   )
 
 lazy val cliPackSettings = Def.settings(
   cliPackLibJars := {
     val s = streams.value
     val log = s.log
 
-    val scalaNativeOrg = "org.scala-native"
+    val scalaNativeOrg = organization.value
     val scalaBinVer = scalaBinaryVersion.value
     val snVer = scalaNativeVersion.value
 
-    val scalaFullVers = crossScalaNative212
+    val scalaFullVers = scalaReleasesForBinaryVersion(scalaBinVer)
     val cliAssemblyJar = assembly.value
 
     // Standard modules needed for linking of Scala Native

cli/src/patches/current/src/test/scala/scala/scalanative/cli/utils/LinktimePropertyParserTest.scala

@@ -9,7 +9,7 @@ class LinktimePropertyParserTest extends AnyFlatSpec {
     val expected =
       Map[String, Any]("isTesting" -> "true", "isNotTesting" -> "False")
     val obtained = LinktimePropertyParser.parseAll(input)
-    assert(obtained.right.get == expected)
+    assert(obtained.contains(expected))
   }
 
   it should "return error on undefined string patterns" in {

cli/src/sbt-test/integration/cli/build.sbt

@@ -11,6 +11,17 @@ val runCli = inputKey[Unit](
 val runExec = inputKey[Unit](
   "Runs given executable (due to problems with exec on Windows)"
 )
+
+scalaVersion := {
+  val scalaVersion = System.getProperty("scala.version")
+  if (scalaVersion == null)
+    throw new RuntimeException(
+      """|The system property 'scala.version' is not defined.
+         |Specify this property using the scriptedLaunchOpts -D.""".stripMargin
+    )
+  else scalaVersion
+}
+
 runCli := {
   val args = spaceDelimited("<arg>").parsed
   val classpath = (Compile / fullClasspath).value.map(_.data.toString())

cli/src/sbt-test/integration/standalone/build.sbt

@@ -13,6 +13,16 @@ val runExec = inputKey[Unit](
   "Runs given executable (due to problems with exec on Windows)"
 )
 
+scalaVersion := {
+  val scalaVersion = System.getProperty("scala.version")
+  if (scalaVersion == null)
+    throw new RuntimeException(
+      """|The system property 'scala.version' is not defined.
+         |Specify this property using the scriptedLaunchOpts -D.""".stripMargin
+    )
+  else scalaVersion
+}
+
 runScript := {
   val scriptName +: rawArgs = spaceDelimited("<arg>").parsed.toSeq
   val cliPackDir = System.getProperty("scala-native-cli-pack")

cli/src/test/scala/scala/scalanative/cli/utils/ConfigConverterTest.scala

@@ -40,8 +40,7 @@ class ConfigConverterTest extends AnyFlatSpec {
     val noArgs = Seq()
     val mainOnlyResult =
       ConfigConverter.convert(dummyCliOptions, dummyMain, noArgs)
-    assert(mainOnlyResult.isLeft)
-    assert(mainOnlyResult.left.get.isInstanceOf[IllegalArgumentException])
+    assert(mainOnlyResult.left.exists(_.isInstanceOf[IllegalArgumentException]))
   }
 
   it should "parse classpath strings correctly" in {
@@ -59,27 +58,23 @@ class ConfigConverterTest extends AnyFlatSpec {
     val config =
       ConfigConverter.convert(dummyCliOptions, dummyMain, classPathStrings)
 
-    assert(config != None)
-    assert(config.right.get.config.classPath.sameElements(expected))
+    assert(config.exists(_.config.classPath.sameElements(expected)))
   }
 
   it should "handle NativeConfig GC correctly" in {
     def gcAssertion(gcString: String, expectedGC: GC) = {
-      val options = CliOptions(
-        dummyConfigOptions,
-        NativeConfigOptions(gc =
-          NativeConfigParserImplicits.gcParser(None, gcString).right.get
-        ),
-        dummyLoggerOptions,
-        dummyMiscOptions
-      )
-      val config =
-        ConfigConverter
+      val parsed = for {
+        gc <- NativeConfigParserImplicits.gcParser(None, gcString)
+        options = CliOptions(
+          dummyConfigOptions,
+          NativeConfigOptions(gc = gc),
+          dummyLoggerOptions,
+          dummyMiscOptions
+        )
+        converted <- ConfigConverter
           .convert(options, dummyMain, dummyArguments)
-          .right
-          .get
-          .config
-      assert(config.compilerConfig.gc == expectedGC)
+      } yield converted.config.gc
+      assert(parsed.contains(expectedGC))
     }
     gcAssertion("immix", GC.immix)
     gcAssertion("commix", GC.commix)
@@ -89,21 +84,17 @@ class ConfigConverterTest extends AnyFlatSpec {
 
   it should "handle NativeConfig Mode correctly" in {
     def modeAssertion(modeString: String, expectedMode: Mode) = {
-      val options = CliOptions(
-        dummyConfigOptions,
-        NativeConfigOptions(mode =
-          NativeConfigParserImplicits.modeParser(None, modeString).right.get
-        ),
-        dummyLoggerOptions,
-        dummyMiscOptions
-      )
-      val config =
-        ConfigConverter
-          .convert(options, dummyMain, dummyArguments)
-          .right
-          .get
-          .config
-      assert(config.compilerConfig.mode == expectedMode)
+      val parsed = for {
+        mode <- NativeConfigParserImplicits.modeParser(None, modeString)
+        options = CliOptions(
+          dummyConfigOptions,
+          NativeConfigOptions(mode = mode),
+          dummyLoggerOptions,
+          dummyMiscOptions
+        )
+        converted <- ConfigConverter.convert(options, dummyMain, dummyArguments)
+      } yield converted.config.compilerConfig.mode
+      assert(parsed.contains(expectedMode))
     }
     modeAssertion("debug", Mode.debug)
     modeAssertion("release-fast", Mode.releaseFast)
@@ -112,21 +103,19 @@ class ConfigConverterTest extends AnyFlatSpec {
 
   it should "handle NativeConfig LTO correctly" in {
     def ltoAssertion(ltoString: String, expectedLto: LTO) = {
-      val options = CliOptions(
-        dummyConfigOptions,
-        NativeConfigOptions(lto =
-          NativeConfigParserImplicits.ltoParser(None, ltoString).right.get
-        ),
-        dummyLoggerOptions,
-        dummyMiscOptions
-      )
-      val config =
-        ConfigConverter
+      val parsed = for {
+        lto <- NativeConfigParserImplicits.ltoParser(None, ltoString)
+        options = CliOptions(
+          dummyConfigOptions,
+          NativeConfigOptions(lto = lto),
+          dummyLoggerOptions,
+          dummyMiscOptions
+        )
+        opts <- ConfigConverter
           .convert(options, dummyMain, dummyArguments)
-          .right
-          .get
-          .config
-      assert(config.compilerConfig.lto == expectedLto)
+      } yield opts.config.compilerConfig.lto
+
+      assert(parsed.contains(expectedLto))
     }
     ltoAssertion("none", LTO.none)
     ltoAssertion("thin", LTO.thin)
@@ -151,10 +140,17 @@ class ConfigConverterTest extends AnyFlatSpec {
     )
 
     val nativeConfig =
-      ConfigConverter.convert(options, dummyMain, dummyArguments).right.get
+      ConfigConverter
+        .convert(options, dummyMain, dummyArguments)
+        .map(_.config.compilerConfig)
+        .fold(
+          fail(_),
+          { config =>
+            assert(config.clang == expectedClangPath)
+            assert(config.clangPP == expectedClangPPPath)
+          }
+        )
 
-    assert(nativeConfig.config.compilerConfig.clang == expectedClangPath)
-    assert(nativeConfig.config.compilerConfig.clangPP == expectedClangPPPath)
   }
 
   it should "parse boolean options as opposite of default" in {
@@ -169,22 +165,23 @@ class ConfigConverterTest extends AnyFlatSpec {
       dummyLoggerOptions,
       dummyMiscOptions
     )
-    val default = ConfigConverter
-      .convert(dummyCliOptions, dummyMain, dummyArguments)
-      .right
-      .get
-      .config
-      .compilerConfig
-    val nonDefault = ConfigConverter
-      .convert(options, dummyMain, dummyArguments)
-      .right
-      .get
-      .config
-      .compilerConfig
-
-    assert(nonDefault.check != default.check)
-    assert(nonDefault.dump != default.dump)
-    assert(nonDefault.optimize != default.optimize)
-    assert(nonDefault.linkStubs != default.linkStubs)
+    val parsed = for {
+      default <- ConfigConverter
+        .convert(dummyCliOptions, dummyMain, dummyArguments)
+        .map(_.config.compilerConfig)
+      nonDefault <- ConfigConverter
+        .convert(options, dummyMain, dummyArguments)
+        .map(_.config.compilerConfig)
+    } yield (default, nonDefault)
+
+    parsed.fold(
+      fail(_),
+      { case (default, nonDefault) =>
+        assert(nonDefault.check != default.check)
+        assert(nonDefault.dump != default.dump)
+        assert(nonDefault.optimize != default.optimize)
+        assert(nonDefault.linkStubs != default.linkStubs)
+      }
+    )
   }
 }