jvm -> scala version in sbt, not yml

.github/workflows/ci.yml

@@ -5,12 +5,11 @@ on:
   push:
 
 jobs:
-  core:
+  test:
     strategy:
       fail-fast: false
       matrix:
-        java: [8, 17, 25]
-        scala: [2.12.x, 2.13.x, 3.3.x]
+        java: [8, 17]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
@@ -20,18 +19,17 @@ jobs:
           java-version: ${{matrix.java}}
           cache: sbt
       - uses: sbt/setup-sbt@v1
-      - run: sbt ++${{matrix.scala}} coreJVM/test coreNative/test cliJVM/test coreJVM/mimaReportBinaryIssues
+      - run: sbt +test +mimaReportBinaryIssues
+      # use of an old sbt version, as a smoke test. only on 2.12.
+      - run: sbt ++2.12.x 'set sbtplugin/scriptedSbt := "1.5.8"' 'sbtplugin/scripted sbt-mima-plugin/minimal'
+        if: matrix.java == 8
 
-  sbtplugin:
-    needs: core
+  scripted:
+    needs: test
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - scala: 2.12.x
-            java: 8
-          - scala: 3.8.x
-            java: 17
+        java: [8, 17]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
@@ -41,11 +39,10 @@ jobs:
           java-version: ${{matrix.java}}
           cache: sbt
       - uses: sbt/setup-sbt@v1
-      # set ThisBuild/scalaVersion because sbtplugin depends on core, but core stays on 2.12 with `++3.8.x`
-      - run: sbt ++${{matrix.scala}} 'set ThisBuild/scalaVersion := (sbtplugin/scalaVersion).value' sbtplugin/mimaReportBinaryIssues sbtplugin/scripted
+      - run: sbt +sbtplugin/scripted
 
-  testFunctional:
-    needs: core
+  functional-tests:
+    needs: test
     strategy:
       fail-fast: false
       matrix:
@@ -59,10 +56,10 @@ jobs:
           java-version: 8
           cache: sbt
       - uses: sbt/setup-sbt@v1
-      - run: sbt "functional-tests/runMain com.typesafe.tools.mima.lib.UnitTests -${{matrix.scala}}"
+      - run: sbt ++2.12.x "functional-tests/runMain com.typesafe.tools.mima.lib.UnitTests -${{matrix.scala}}"
 
-  testIntegration:
-    needs: core
+  integration-tests:
+    needs: test
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
@@ -72,4 +69,4 @@ jobs:
           java-version: 8
           cache: sbt
       - uses: sbt/setup-sbt@v1
-      - run: sbt integration-tests/test
+      - run: sbt ++2.12.x integration-tests/test

.github/workflows/release.yml

@@ -4,40 +4,12 @@ on:
   push:
     tags: ["*"]
 
-env:
-  PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}
-  PGP_SECRET: ${{ secrets.PGP_SECRET }}
-  SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-  SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
-
 jobs:
-  release-core-cli:
-    strategy:
-      fail-fast: false
-      matrix:
-        scala: [2.12.x, 2.13.x, 3.3.x]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-java@v5
-        with:
-          distribution: temurin
-          java-version: 8
-          cache: sbt
-      - uses: sbt/setup-sbt@v1
-      - run: sbt ++${{matrix.scala}} coreJVM/publishSigned coreNative/publishSigned cliJVM/publishSigned
-
-  release-sbtplugin:
+  release:
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - scala: 2.12.x
-            java: 8
-          - scala: 3.8.x
-            java: 17
+        java: [8, 17]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
@@ -49,5 +21,9 @@ jobs:
           java-version: ${{matrix.java}}
           cache: sbt
       - uses: sbt/setup-sbt@v1
-      # set ThisBuild/scalaVersion because sbtplugin depends on core, but core stays on 2.12 with `++3.8.x`
-      - run: sbt ++${{matrix.scala}} 'set ThisBuild/scalaVersion := (sbtplugin/scalaVersion).value' sbtplugin/publishSigned
+      - run: sbt ci-release
+        env:
+          PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }}
+          PGP_SECRET: ${{ secrets.PGP_SECRET }}
+          SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
+          SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}

build.sbt

@@ -1,4 +1,6 @@
-import mimabuild._
+import mimabuild.*
+
+import scala.util.Properties
 
 inThisBuild(Seq(
   organization := "com.typesafe",
@@ -11,9 +13,18 @@ inThisBuild(Seq(
   ),
   scmInfo := Some(ScmInfo(url("https://github.com/lightbend-labs/mima"), "scm:git:git@github.com:lightbend-labs/mima.git")),
   versionScheme := Some("early-semver"),
-  scalaVersion := scala212,
 ))
 
+lazy val commonSettings: Seq[Setting[_]] = Seq(
+  // in order to build `sbtplugin`, the `scalaVersion` of `core.jvm` has to match (2.12 or 3.8)
+  scalaVersion := crossScalaVersions.value.headOption.getOrElse((LocalProject("sbtplugin") / scalaVersion).value),
+  publish / skip := crossScalaVersions.value.isEmpty,
+  publishLocal / skip := false, // sbtplugin/scripted requires publishLocal
+  scalacOptions ++= compilerOptions(scalaVersion.value),
+)
+
+def java8or17[T](if8: => T, if17: => T): T = if (Properties.isJavaAtLeast("17")) if17 else if8
+
 def compilerOptions(scalaVersion: String): Seq[String] =
   Seq(
     "-feature",
@@ -36,23 +47,22 @@ def compilerOptions(scalaVersion: String): Seq[String] =
 // Keep in sync with TestCli
 val scala212 = "2.12.21"
 val scala213 = "2.13.18"
-val scala3 = "3.3.7"   // keep at LTS
+val scala3_3 = "3.3.7" // keep at LTS
 val scala3_8 = "3.8.1" // keep at 3.8 for sbt 2 plugin
 
-val root = project.in(file(".")).settings(
+val root = project.in(file(".")).settings(commonSettings).settings(
   name := "mima",
   crossScalaVersions := Nil,
   mimaFailOnNoPrevious := false,
-  publish / skip := true,
 )
+
 aggregateProjects(core.jvm, core.native, cli.jvm, sbtplugin, functionalTests, integrationTests)
 
 val munit = Def.setting("org.scalameta" %%% "munit" % "1.2.2")
 
-val core = crossProject(JVMPlatform, NativePlatform).crossType(CrossType.Pure).settings(
+val core = crossProject(JVMPlatform, NativePlatform).crossType(CrossType.Pure).settings(commonSettings).settings(
   name := "mima-core",
-  crossScalaVersions ++= Seq(scala213, scala3),
-  scalacOptions ++= compilerOptions(scalaVersion.value),
+  crossScalaVersions := java8or17(Seq(scala212, scala213, scala3_3), Nil),
   libraryDependencies += munit.value % Test,
   MimaSettings.mimaSettings,
   apiMappings ++= {
@@ -69,28 +79,24 @@ val core = crossProject(JVMPlatform, NativePlatform).crossType(CrossType.Pure).s
 
 val cli = crossProject(JVMPlatform)
   .crossType(CrossType.Pure)
+  .settings(commonSettings)
   .settings(
     name := "mima-cli",
-    crossScalaVersions ++= Seq(scala213, scala3),
-    scalacOptions ++= compilerOptions(scalaVersion.value),
+    crossScalaVersions := java8or17(Seq(scala212, scala213, scala3_3), Nil),
     libraryDependencies += munit.value % Test,
-    MimaSettings.mimaSettings,
-    // cli has no previous release,
-    // but also we don't care about its binary compatibility as it's meant to be used standalone
-    mimaPreviousArtifacts := Set.empty
+    mimaFailOnNoPrevious := false,
   )
   .dependsOn(core)
 
-val sbtplugin = project.enablePlugins(SbtPlugin).dependsOn(core.jvm).settings(
+val sbtplugin = project.enablePlugins(SbtPlugin).dependsOn(core.jvm).settings(commonSettings).settings(
   name := "sbt-mima-plugin",
-  crossScalaVersions ++= Seq(scala3_8),
+  crossScalaVersions := java8or17(Seq(scala212), Seq(scala3_8)),
   (pluginCrossBuild / sbtVersion) := {
     scalaBinaryVersion.value match {
       case "2.12" => "1.5.8"
       case _      => "2.0.0-RC9"
     }
   },
-  scalacOptions ++= compilerOptions(scalaVersion.value),
   // drop the previous value to drop running Test/compile
   scriptedDependencies := Def.task(()).dependsOn(publishLocal, core.jvm / publishLocal).value,
   scriptedLaunchOpts += s"-Dplugin.version=${version.value}",
@@ -104,26 +110,26 @@ val sbtplugin = project.enablePlugins(SbtPlugin).dependsOn(core.jvm).settings(
 val testFunctional = taskKey[Unit]("Run the functional test")
 val functionalTests = Project("functional-tests", file("functional-tests"))
   .dependsOn(core.jvm)
+  .settings(commonSettings)
   .settings(
-    crossScalaVersions += scala213,
+    crossScalaVersions := java8or17(Seq(scala212, scala213), Nil),
+    publish / skip := true,
     libraryDependencies += "io.get-coursier" %% "coursier" % "2.1.24",
     libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,
     libraryDependencies += munit.value,
-    scalacOptions ++= compilerOptions(scalaVersion.value),
     testFunctional := (Test / test).value,
     Test / mainClass := Some("com.typesafe.tools.mima.lib.UnitTests"),
     mimaFailOnNoPrevious := false,
-    publish / skip := true,
   )
 
 val integrationTests = Project("integration-tests", file("integration-tests"))
   .dependsOn(functionalTests % "compile->compile")
+  .settings(commonSettings)
   .settings(
-    crossScalaVersions += scala213,
+    crossScalaVersions := java8or17(Seq(scala212, scala213), Nil),
+    publish / skip := true,
     libraryDependencies += munit.value,
-    scalacOptions ++= compilerOptions(scalaVersion.value),
     Test / unmanagedSourceDirectories := Seq((functionalTests / baseDirectory).value / "src" / "it" / "scala"),
     Test / testOptions += Tests.Argument(TestFrameworks.MUnit, "-b"), // disable buffering => immediate output
     mimaFailOnNoPrevious := false,
-    publish / skip := true,
   )