Fix sbt project

Author: steinybot

.github/workflows/ci.yml

@@ -52,20 +52,8 @@ jobs:
       - name: Check that workflows are up to date
         run: sbt ++${{ matrix.scala }} githubWorkflowCheck
 
-      - name: Check formatting and style
-        run: sbt ++${{ matrix.scala }} scalafmtCheckAll scalastyle
-
-      - name: Check version adheres to the policy
-        run: sbt ++${{ matrix.scala }} versionPolicyCheck
-
-      - name: Check documentation has been generated
-        run: sbt ++${{ matrix.scala }} mdocCheck
-
-      - name: Check dependencies
-        run: sbt ++${{ matrix.scala }} evicted undeclaredCompileDependenciesTest unusedCompileDependenciesTest dependencyCheckAggregate
-
-      - name: Build and test
-        run: sbt ++${{ matrix.scala }} test
+      - name: Build, test and check libraries
+        run: sbt ++${{ matrix.scala }} check
 
       - name: Build and test sbt plugin
         if: matrix.scala == '2.12.13'

build.sbt

@@ -11,7 +11,7 @@ val utestVersion                        = "0.7.7"
 addCommandAlias(
   "devCheck",
   supportedScalaVersions.flatMap { version =>
-    s"++$version" :: "check" :: (if (version == scala213) Nil else List("scripted"))
+    s"++$version" :: "githubWorkflowCheck" :: "check" :: (if (version == scala213) Nil else List("scripted"))
   }.mkString(";")
 )
 
@@ -166,7 +166,7 @@ lazy val sbtProject = (project in file("sbt"))
     libraryDependencies ++= {
       // Only add dependencies when the build is building with a Scala version that is
       // sbt compatible otherwise it will cause a whole lot of resolution failures.
-      if (spspIsSbtCompatibleScalaVersion.value)
+      if (spspCanBuild.value)
         collectionsCompatibilityDependency.value ++ List(
           "org.scala-sbt" %% "collections"            % sbtVersion.value,
           "org.scala-sbt" %% "command"                % sbtVersion.value,

project/ConditionalKeys.scala

@@ -6,8 +6,9 @@ object ConditionalKeys {
   def settingDefaultIfSetting[A, B](
       setting: Def.Initialize[A],
       condition: Def.Initialize[B],
-      p: B => Boolean,
-      default: A
+      default: => A
+    )(
+      p: B => Boolean
     ): Def.Initialize[A] = Def.setting {
     if (p(condition.value)) {
       default
@@ -16,14 +17,15 @@ object ConditionalKeys {
     }
   }
 
-  def taskDefaultIfSkipped[A](task: TaskKey[A], default: A): Def.Initialize[Task[A]] =
-    taskDefaultIfTask[A, Boolean](task, task / skip, identity, default)
+  def taskDefaultIfSkipped[A](task: TaskKey[A], default: => A): Def.Initialize[Task[A]] =
+    taskDefaultIfTask(task, task / skip, default)(identity)
 
   def taskDefaultIfSetting[A, B](
       task: Def.Initialize[Task[A]],
       condition: Def.Initialize[B],
-      p: B => Boolean,
-      default: A
+      default: => A
+    )(
+      p: B => Boolean
     ): Def.Initialize[Task[A]] = Def.taskIf {
     if (p(condition.value)) {
       default
@@ -35,8 +37,9 @@ object ConditionalKeys {
   def taskDefaultIfTask[A, B](
       task: Def.Initialize[Task[A]],
       condition: Def.Initialize[Task[B]],
-      p: B => Boolean,
-      default: A
+      default: => A
+    )(
+      p: B => Boolean
     ): Def.Initialize[Task[A]] = Def.taskIf {
     if (p(condition.value)) {
       default
@@ -45,14 +48,15 @@ object ConditionalKeys {
     }
   }
 
-  def inputDefaultIfSkipped[A](input: InputKey[A], default: A): Def.Initialize[InputTask[A]] =
-    inputDefaultIfTask[A, Boolean](input, input / skip, identity, default)
+  def inputDefaultIfSkipped[A](input: InputKey[A], default: => A): Def.Initialize[InputTask[A]] =
+    inputDefaultIfTask(input, input / skip, default)(identity)
 
   def inputDefaultIfTask[A, B](
       input: InputKey[A],
       condition: Def.Initialize[Task[B]],
-      p: B => Boolean,
-      default: A
+      default: => A
+    )(
+      p: B => Boolean
     ): Def.Initialize[InputTask[A]] = Def.inputTaskDyn {
     val task = input.parsed
     Def.taskIf {

project/SbtPluginSubProjectPlugin.scala

@@ -1,18 +1,21 @@
 import ConditionalKeys._
+import com.typesafe.tools.mima.plugin.MimaKeys.mimaPreviousArtifacts
+import explicitdeps.ExplicitDepsPlugin
 import explicitdeps.ExplicitDepsPlugin.autoImport._
 import sbt.Keys._
 import sbt.ScriptedPlugin.autoImport.scripted
+import sbt._
 import sbt.plugins.SbtPlugin
-import sbt.{Def, _}
+import sbtversionpolicy.SbtVersionPolicyMima
 
 // This is all the crazy hacks to get cross compiling working with an sub-project that is an sbt plugin.
 object SbtPluginSubProjectPlugin extends AutoPlugin {
 
   override def trigger: PluginTrigger = allRequirements
-  override def requires: Plugins      = SbtPlugin
+  override def requires: Plugins      = SbtPlugin && SbtVersionPolicyMima && ExplicitDepsPlugin
 
   object autoImport {
-    val spspIsSbtCompatibleScalaVersion = settingKey[Boolean]("Checks if the current Scala version is 2.13")
+    val spspCanBuild = settingKey[Boolean]("Checks if the project dependencies are using a compatible Scala version.")
   }
 
   import autoImport._
@@ -21,29 +24,35 @@ object SbtPluginSubProjectPlugin extends AutoPlugin {
     List(
       crossScalaVersions := Nil,
       // Remove all library dependencies for Scala 2.13 as they will not resolve when cross building.
-      libraryDependencies := settingDefaultIfSetting(libraryDependencies, scalaVersion, isScala213, Nil).value,
+//      libraryDependencies := defaultIfCannotBuild(libraryDependencies, Nil).value,
       // Remove all project dependencies for Scala 2.13 as they will not resolve when cross building.
       projectDependencies := taskDefaultIfSkipped(projectDependencies, Nil).value,
       scripted := inputDefaultIfSkipped(scripted, ()).evaluated,
-      spspIsSbtCompatibleScalaVersion := isSbtCompatibleScalaVersionSetting.value,
+      spspCanBuild := canBuildSetting.value,
       // We can't skip this as it has to run at least once or sbt complains.
       update / skip := false,
       // Skip everything else otherwise it will just fail.
-      skip := !spspIsSbtCompatibleScalaVersion.value,
-      undeclaredCompileDependenciesFilter -= moduleFilter()
+      skip := !spspCanBuild.value,
+      undeclaredCompileDependenciesFilter -= moduleFilter(),
+      mimaPreviousArtifacts := defaultIfCannotBuild(mimaPreviousArtifacts, Set.empty[ModuleID]).value
     )
 
-  private def isSbtCompatibleScalaVersionSetting = Def.setting {
-    if (isScala213(scalaVersion.value))
-      throw new IllegalStateException("sbt project must not use Scala 2.13. Did you force the version with '+'?")
+  def defaultIfCannotBuild[A](setting: Def.Initialize[A], default: => A): Def.Initialize[A] =
+    settingDefaultIfSetting(setting, spspCanBuild, default)(!_)
+
+  private def canBuildSetting = Def.setting {
+    if (!isScala212(scalaVersion.value))
+      throw new IllegalStateException(
+        "sbt project must use Scala 2.12. Check that you have not forced the version with '+'."
+      )
     val versions =
       scalaVersion.all(ScopeFilter(inDependencies(ThisProject, transitive = true, includeRoot = false))).value
-    !versions.exists(isScala213)
+    versions.forall(isScala212)
   }
 
-  private def isScala213(version: String) =
+  private def isScala212(version: String) =
     CrossVersion.partialVersion(version) match {
-      case Some((2, n)) if n == 13 => true
+      case Some((2, n)) if n == 12 => true
       case _                       => false
     }
 }