Provide a test to replicate issue #102

plugin/src/main/scala/io/github/davidgregory084/TpolecatPlugin.scala

@@ -48,7 +48,7 @@ object TpolecatPlugin extends AutoPlugin {
           Set.empty[ScalacOption]
       }
 
-      supportedOptions.toList.flatMap(opt => opt.option :: opt.args)
+      supportedOptions.toList.sortBy(_.option).flatMap(opt => opt.option :: opt.args)
     }
 
     val tpolecatDefaultOptionsMode = settingKey[OptionsMode](
@@ -113,42 +113,43 @@ object TpolecatPlugin extends AutoPlugin {
     tpolecatDevModeEnvVar      := "SBT_TPOLECAT_DEV",
     tpolecatCiModeEnvVar       := "SBT_TPOLECAT_CI",
     tpolecatReleaseModeEnvVar  := "SBT_TPOLECAT_RELEASE",
+    tpolecatDevModeOptions     := Set.empty,
+    tpolecatCiModeOptions      := Set.empty,
+    tpolecatReleaseModeOptions := Set.empty,
     tpolecatOptionsMode := {
       if (sys.env.contains(tpolecatReleaseModeEnvVar.value)) ReleaseMode
       else if (sys.env.contains(tpolecatCiModeEnvVar.value)) CiMode
       else if (sys.env.contains(tpolecatDevModeEnvVar.value)) DevMode
       else tpolecatDefaultOptionsMode.value
-    },
-    tpolecatDevModeOptions := ScalacOptions.default
+    }
   ) ++ commandAliases
 
-  override def projectSettings: Seq[Setting[_]] = Seq(
-    Def.derive(
-      scalacOptions := {
-        val pluginOptions   = tpolecatScalacOptions.value
-        val pluginExcludes  = tpolecatExcludeOptions.value
-        val selectedOptions = pluginOptions.diff(pluginExcludes)
-        scalacOptionsFor(scalaVersion.value, selectedOptions)
-      }
-    ),
-    Def.derive(
-      tpolecatCiModeOptions := tpolecatDevModeOptions.value + ScalacOptions.fatalWarnings
-    ),
-    Def.derive(
-      tpolecatReleaseModeOptions := tpolecatCiModeOptions.value + ScalacOptions.optimizerMethodLocal
-    ),
-    Def.derive(tpolecatScalacOptions := {
+  def sbtTpolecatSettings: Seq[Setting[_]] = Seq(
+    tpolecatExcludeOptions := Set.empty,
+    console / tpolecatExcludeOptions ++= ScalacOptions.defaultConsoleExclude,
+    tpolecatDevModeOptions ++= ScalacOptions.default,
+    tpolecatCiModeOptions ++= tpolecatDevModeOptions.value + ScalacOptions.fatalWarnings,
+    tpolecatReleaseModeOptions ++= tpolecatCiModeOptions.value + ScalacOptions.optimizerMethodLocal,
+    tpolecatScalacOptions := {
       tpolecatOptionsMode.value match {
         case DevMode     => tpolecatDevModeOptions.value
         case CiMode      => tpolecatCiModeOptions.value
         case ReleaseMode => tpolecatReleaseModeOptions.value
       }
-    }),
-    Compile / console / tpolecatExcludeOptions ++= ScalacOptions.defaultConsoleExclude,
-    Test / console / tpolecatExcludeOptions ++= ScalacOptions.defaultConsoleExclude
+    },
+    scalacOptions := {
+      val previousOptions = scalacOptions.value
+      val pluginOptions   = tpolecatScalacOptions.value
+      val pluginExcludes  = tpolecatExcludeOptions.value
+      val selectedOptions = pluginOptions.diff(pluginExcludes)
+      previousOptions ++ scalacOptionsFor(scalaVersion.value, selectedOptions)
+    }
   )
 
-  override def globalSettings: Seq[Def.Setting[_]] = Seq(
-    tpolecatExcludeOptions := Set.empty
+  override def projectSettings: Seq[Setting[_]] = Def.settings(
+    inConfig(Compile)(sbtTpolecatSettings),
+    inConfig(Test)(sbtTpolecatSettings)
   )
+
+  override def globalSettings: Seq[Def.Setting[_]] = Seq.empty
 }

plugin/src/sbt-test/sbt-tpolecat/modePerConfiguration/build.sbt

@@ -22,14 +22,20 @@ Test / tpolecatOptionsMode    := DevMode
 
 TaskKey[Unit]("checkCompileOptions") := {
   val hasFatalWarnings =
-    scalacOptions.value.contains("-Xfatal-warnings")
+    (Compile / scalacOptions).value.contains("-Xfatal-warnings")
 
-  assert(hasFatalWarnings)
+  val scalaV =
+    scalaVersion.value
+
+  assert(hasFatalWarnings, s"Compile options does not contain expected fatal warnings option for $scalaV")
 }
 
 TaskKey[Unit]("checkTestOptions") := {
   val hasFatalWarnings =
     (Test / scalacOptions).value.contains("-Xfatal-warnings")
 
-  assert(!hasFatalWarnings)
+  val scalaV =
+    scalaVersion.value
+
+  assert(!hasFatalWarnings, s"Test options contains unexpected fatal warnings option for $scalaV")
 }

plugin/src/sbt-test/sbt-tpolecat/scalaJs/build.sbt

@@ -0,0 +1,30 @@
+import munit.Assertions._
+
+val Scala211 = "2.11.12"
+val Scala212 = "2.12.16"
+val Scala213 = "2.13.8"
+val Scala30  = "3.0.2"
+val Scala31  = "3.1.3"
+
+crossScalaVersions := Seq(
+  Scala211,
+  Scala212,
+  Scala213,
+  Scala30,
+  Scala31
+)
+
+enablePlugins(ScalaJSPlugin)
+
+TaskKey[Unit]("checkScalaJsOption") := {
+  val actualOptions = (Compile / scalacOptions).value
+
+  scalaVersion.value match {
+    case Scala30 =>
+      assert(actualOptions.contains("-scalajs"), "The -scalajs option was not present on Scala 3.0")
+    case Scala31 =>
+      assert(actualOptions.contains("-scalajs"), "The -scalajs option was not present on Scala 3.1")
+    case _ =>
+      assert(!actualOptions.contains("-scalajs"), "The -scalajs option was present on Scala 2.x")
+  }
+}

plugin/src/sbt-test/sbt-tpolecat/scalaJs/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.7.1

plugin/src/sbt-test/sbt-tpolecat/scalaJs/project/build.sbt

@@ -0,0 +1 @@
+libraryDependencies += "org.scalameta" %% "munit" % "0.7.29"

plugin/src/sbt-test/sbt-tpolecat/scalaJs/project/plugins.sbt

@@ -0,0 +1,2 @@
+addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % System.getProperty("plugin.version"))
+addSbtPlugin("org.scala-js"              % "sbt-scalajs"  % "1.10.1")

plugin/src/sbt-test/sbt-tpolecat/scalaJs/src/main/scala/Test.scala

@@ -0,0 +1,3 @@
+object Test {
+  def main(args: Array[String]): Unit = println("yo")
+}

plugin/src/sbt-test/sbt-tpolecat/scalaJs/test

@@ -0,0 +1,2 @@
+> +checkScalaJsOption
+> +compile

plugin/src/sbt-test/sbt-tpolecat/scalacOptions/build.sbt

@@ -29,15 +29,6 @@ tpolecatReleaseModeOptions ++= {
 
 val Scala211Options =
   Seq(
-    "-encoding",
-    "utf8",
-    "-deprecation",
-    "-feature",
-    "-unchecked",
-    "-language:existentials",
-    "-language:experimental.macros",
-    "-language:higherKinds",
-    "-language:implicitConversions",
     "-Xlint:adapted-args",
     "-Xlint:by-name-right-associative",
     "-Xlint:delayedinit-select",
@@ -62,20 +53,20 @@ val Scala211Options =
     "-Ywarn-numeric-widen",
     "-Ywarn-unused",
     "-Ywarn-unused-import",
-    "-Ywarn-value-discard"
-  )
-
-val Scala212Options =
-  Seq(
+    "-Ywarn-value-discard",
+    "-deprecation",
     "-encoding",
     "utf8",
-    "-deprecation",
     "-feature",
-    "-unchecked",
     "-language:existentials",
     "-language:experimental.macros",
     "-language:higherKinds",
     "-language:implicitConversions",
+    "-unchecked",
+  )
+
+val Scala212Options =
+  Seq(
     "-Xlint:adapted-args",
     "-Xlint:by-name-right-associative",
     "-Xlint:constant",
@@ -93,40 +84,54 @@ val Scala212Options =
     "-Xlint:stars-align",
     "-Xlint:type-parameter-shadow",
     "-Xlint:unsound-match",
+    "-Xsource:2.13",
     "-Yno-adapted-args",
     "-Ypartial-unification",
     "-Ywarn-dead-code",
     "-Ywarn-extra-implicit",
     "-Ywarn-nullary-override",
     "-Ywarn-nullary-unit",
     "-Ywarn-numeric-widen",
-    "-Ywarn-value-discard",
     "-Ywarn-unused:implicits",
     "-Ywarn-unused:imports",
     "-Ywarn-unused:locals",
     "-Ywarn-unused:params",
     "-Ywarn-unused:patvars",
     "-Ywarn-unused:privates",
-    "-Xsource:2.13"
-  )
-
-val Scala213Options =
-  Seq(
+    "-Ywarn-value-discard",
+    "-deprecation",
     "-encoding",
     "utf8",
     "-feature",
-    "-unchecked",
     "-language:existentials",
     "-language:experimental.macros",
     "-language:higherKinds",
     "-language:implicitConversions",
+    "-unchecked",
+  )
+
+val Scala213Options =
+  Seq(
+    "-Wdead-code",
+    "-Wextra-implicit",
+    "-Wnumeric-widen",
+    "-Wunused:explicits",
+    "-Wunused:implicits",
+    "-Wunused:imports",
+    "-Wunused:locals",
+    "-Wunused:nowarn",
+    "-Wunused:params",
+    "-Wunused:patvars",
+    "-Wunused:privates",
+    "-Wvalue-discard",
+    "-Xlint:-byname-implicit",
     "-Xlint:adapted-args",
     "-Xlint:constant",
     "-Xlint:delayedinit-select",
     "-Xlint:deprecation",
     "-Xlint:doc-detached",
-    "-Xlint:implicit-recursion",
     "-Xlint:implicit-not-found",
+    "-Xlint:implicit-recursion",
     "-Xlint:inaccessible",
     "-Xlint:infer-any",
     "-Xlint:missing-interpolator",
@@ -138,50 +143,45 @@ val Scala213Options =
     "-Xlint:stars-align",
     "-Xlint:strict-unsealed-patmat",
     "-Xlint:type-parameter-shadow",
-    "-Xlint:-byname-implicit",
-    "-Wdead-code",
-    "-Wextra-implicit",
-    "-Wnumeric-widen",
-    "-Wvalue-discard",
-    "-Wunused:nowarn",
-    "-Wunused:implicits",
-    "-Wunused:explicits",
-    "-Wunused:imports",
-    "-Wunused:locals",
-    "-Wunused:params",
-    "-Wunused:patvars",
-    "-Wunused:privates",
-    "-Xsource:2.13"
+    "-Xsource:2.13",
+    "-encoding",
+    "utf8",
+    "-feature",
+    "-language:existentials",
+    "-language:experimental.macros",
+    "-language:higherKinds",
+    "-language:implicitConversions",
+    "-unchecked",
   )
 
 val Scala30Options =
   Seq(
+    "-Ykind-projector",
+    "-deprecation",
     "-encoding",
     "utf8",
-    "-deprecation",
     "-feature",
-    "-unchecked",
     "-language:experimental.macros",
     "-language:higherKinds",
     "-language:implicitConversions",
-    "-Ykind-projector",
     "-source",
-    "3.0-migration"
+    "3.0-migration",
+    "-unchecked",
   )
 
 val Scala31Options =
   Seq(
+    "-Ykind-projector",
+    "-deprecation",
     "-encoding",
     "utf8",
-    "-deprecation",
     "-feature",
-    "-unchecked",
     "-language:experimental.macros",
     "-language:higherKinds",
     "-language:implicitConversions",
-    "-Ykind-projector",
     "-source",
-    "3.0-migration"
+    "3.0-migration",
+    "-unchecked",
   )
 
 TaskKey[Unit]("checkDevMode") := {
@@ -195,25 +195,33 @@ TaskKey[Unit]("checkDevMode") := {
     case Scala31  => Scala31Options
   }
 
-  val actualOptions = scalacOptions.value
+  val actualOptions = (Compile / scalacOptions).value
 
-  assertEquals(actualOptions, expectedOptions)
+  assertEquals(
+    actualOptions,
+    expectedOptions,
+    s"Expected dev mode options were not applied for $scalaV"
+  )
 }
 
 TaskKey[Unit]("checkCiMode") := {
   val scalaV = scalaVersion.value
 
   val expectedOptions = scalaV match {
-    case Scala211 => Scala211Options ++ Seq("-Xfatal-warnings")
-    case Scala212 => Scala212Options ++ Seq("-Xfatal-warnings")
-    case Scala213 => Scala213Options ++ Seq("-Xfatal-warnings")
-    case Scala30  => Scala30Options ++ Seq("-Xfatal-warnings")
-    case Scala31  => Scala31Options ++ Seq("-Xfatal-warnings")
+    case Scala211 => "-Xfatal-warnings" +: Scala211Options
+    case Scala212 => Scala212Options
+    case Scala213 => Scala213Options
+    case Scala30  => Scala30Options
+    case Scala31  => Scala31Options
   }
 
-  val actualOptions = scalacOptions.value
+  val actualOptions = (Compile / scalacOptions).value
 
-  assertEquals(actualOptions, expectedOptions)
+  assertEquals(
+    actualOptions,
+    expectedOptions,
+    s"Expected CI mode options were not applied for $scalaV"
+  )
 }
 
 TaskKey[Unit]("checkReleaseMode") := {
@@ -251,9 +259,13 @@ TaskKey[Unit]("checkReleaseMode") := {
     case Scala31 => Scala31Options ++ fatalWarnings ++ releaseOptions
   }
 
-  val actualOptions = scalacOptions.value
+  val actualOptions = (Compile / scalacOptions).value
 
-  assertEquals(actualOptions, expectedOptions)
+  assertEquals(
+    actualOptions,
+    expectedOptions,
+    s"Expected release mode options were not applied for $scalaV"
+  )
 }
 
 TaskKey[Unit]("checkConsoleScalacOptions") := {