Refactor sbt project workarounds

Author: steinybot

build.sbt

@@ -164,10 +164,9 @@ lazy val sbtProject = (project in file("sbt"))
   .settings(commonProjectSettings)
   .settings(
     libraryDependencies ++= {
-      // Don't add dependencies when the rest of the build is cross building with Scala 2.13
-      // otherwise it will cause a whole lot of resolution failures.
-      if ((core / isScala213).value) Nil
-      else
+      // 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)
         collectionsCompatibilityDependency.value ++ List(
           "org.scala-sbt" %% "collections"            % sbtVersion.value,
           "org.scala-sbt" %% "command"                % sbtVersion.value,
@@ -183,6 +182,7 @@ lazy val sbtProject = (project in file("sbt"))
           "org.scala-sbt" %% "util-logging"           % sbtVersion.value,
           "org.scala-sbt" %% "util-position"          % sbtVersion.value
         )
+      else Nil
     },
     name := s"sbt-${(LocalRootProject / name).value}",
     scriptedBufferLog := false,

project/ConditionalKeys.scala

@@ -0,0 +1,66 @@
+import sbt.Keys.skip
+import sbt.{Def, InputKey, InputTask, Task, TaskKey}
+
+object ConditionalKeys {
+
+  def settingDefaultIfSetting[A, B](
+      setting: Def.Initialize[A],
+      condition: Def.Initialize[B],
+      p: B => Boolean,
+      default: A
+    ): Def.Initialize[A] = Def.setting {
+    if (p(condition.value)) {
+      default
+    } else {
+      setting.value
+    }
+  }
+
+  def taskDefaultIfSkipped[A](task: TaskKey[A], default: A): Def.Initialize[Task[A]] =
+    taskDefaultIfTask[A, Boolean](task, task / skip, identity, default)
+
+  def taskDefaultIfSetting[A, B](
+      task: Def.Initialize[Task[A]],
+      condition: Def.Initialize[B],
+      p: B => Boolean,
+      default: A
+    ): Def.Initialize[Task[A]] = Def.taskIf {
+    if (p(condition.value)) {
+      default
+    } else {
+      task.value
+    }
+  }
+
+  def taskDefaultIfTask[A, B](
+      task: Def.Initialize[Task[A]],
+      condition: Def.Initialize[Task[B]],
+      p: B => Boolean,
+      default: A
+    ): Def.Initialize[Task[A]] = Def.taskIf {
+    if (p(condition.value)) {
+      default
+    } else {
+      task.value
+    }
+  }
+
+  def inputDefaultIfSkipped[A](input: InputKey[A], default: A): Def.Initialize[InputTask[A]] =
+    inputDefaultIfTask[A, Boolean](input, input / skip, identity, default)
+
+  def inputDefaultIfTask[A, B](
+      input: InputKey[A],
+      condition: Def.Initialize[Task[B]],
+      p: B => Boolean,
+      default: A
+    ): Def.Initialize[InputTask[A]] = Def.inputTaskDyn {
+    val task = input.parsed
+    Def.taskIf {
+      if (p(condition.value)) {
+        default
+      } else {
+        task.value
+      }
+    }
+  }
+}

project/SbtPluginSubProjectPlugin.scala

@@ -0,0 +1,49 @@
+import ConditionalKeys._
+import explicitdeps.ExplicitDepsPlugin.autoImport._
+import sbt.Keys._
+import sbt.ScriptedPlugin.autoImport.scripted
+import sbt.plugins.SbtPlugin
+import sbt.{Def, _}
+
+// 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
+
+  object autoImport {
+    val spspIsSbtCompatibleScalaVersion = settingKey[Boolean]("Checks if the current Scala version is 2.13")
+  }
+
+  import autoImport._
+
+  override def projectSettings: Seq[Def.Setting[_]] =
+    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,
+      // 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,
+      // 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()
+    )
+
+  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 '+'?")
+    val versions =
+      scalaVersion.all(ScopeFilter(inDependencies(ThisProject, transitive = true, includeRoot = false))).value
+    !versions.exists(isScala213)
+  }
+
+  private def isScala213(version: String) =
+    CrossVersion.partialVersion(version) match {
+      case Some((2, n)) if n == 13 => true
+      case _                       => false
+    }
+}