From 411232d1155c4a0dea18a22f49592e5b1c295334 Mon Sep 17 00:00:00 2001 From: Kai <450507+neko-kai@users.noreply.github.com> Date: Thu, 13 Oct 2022 21:13:29 +0100 Subject: [PATCH] scala3: remove copypaste across versions for VersionSpecificDurationConverters --- build.sbt | 630 +++++++++++++++--- ...sionSpecificDurationConvertersCompat.scala | 0 ...sionSpecificDurationConvertersCompat.scala | 11 - project/Deps.sc | 16 +- 4 files changed, 533 insertions(+), 124 deletions(-) rename fundamentals/fundamentals-bio/src/main/{scala-2.13 => scala-2.13+}/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala (100%) delete mode 100644 fundamentals/fundamentals-bio/src/main/scala-3/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala diff --git a/build.sbt b/build.sbt index 566a3d2c5f..38c73973f0 100644 --- a/build.sbt +++ b/build.sbt @@ -37,6 +37,26 @@ lazy val `fundamentals-functional` = project.in(file("fundamentals/fundamentals- s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -177,6 +197,26 @@ lazy val `fundamentals-collections` = project.in(file("fundamentals/fundamentals s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -277,27 +317,7 @@ lazy val `fundamentals-collections` = project.in(file("fundamentals/fundamentals "-opt-inline-from:izumi.**" ) case (_, _) => Seq.empty - } }, - Compile / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Compile / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - }, - Test / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Test / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - } + } } ) .disablePlugins(AssemblyPlugin) @@ -335,6 +355,26 @@ lazy val `fundamentals-literals` = project.in(file("fundamentals/fundamentals-li s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -477,6 +517,26 @@ lazy val `fundamentals-orphans` = project.in(file("fundamentals/fundamentals-orp s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -626,6 +686,26 @@ lazy val `fundamentals-language` = project.in(file("fundamentals/fundamentals-la s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -726,27 +806,7 @@ lazy val `fundamentals-language` = project.in(file("fundamentals/fundamentals-la "-opt-inline-from:izumi.**" ) case (_, _) => Seq.empty - } }, - Compile / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Compile / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - }, - Test / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Test / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - } + } } ) .disablePlugins(AssemblyPlugin) @@ -788,6 +848,26 @@ lazy val `fundamentals-platform` = project.in(file("fundamentals/fundamentals-pl s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -941,6 +1021,26 @@ lazy val `fundamentals-json-circe` = project.in(file("fundamentals/fundamentals- s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1084,6 +1184,26 @@ lazy val `fundamentals-reflection` = project.in(file("fundamentals/fundamentals- s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1184,27 +1304,7 @@ lazy val `fundamentals-reflection` = project.in(file("fundamentals/fundamentals- "-opt-inline-from:izumi.**" ) case (_, _) => Seq.empty - } }, - Compile / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Compile / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - }, - Test / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Test / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - } + } } ) .disablePlugins(AssemblyPlugin) @@ -1255,6 +1355,26 @@ lazy val `fundamentals-bio` = project.in(file("fundamentals/fundamentals-bio")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1405,6 +1525,26 @@ lazy val `distage-core-api` = project.in(file("distage/distage-core-api")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1546,6 +1686,26 @@ lazy val `distage-core-proxy-bytebuddy` = project.in(file("distage/distage-core- s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1687,6 +1847,26 @@ lazy val `distage-framework-api` = project.in(file("distage/distage-framework-ap s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1834,6 +2014,26 @@ lazy val `distage-core` = project.in(file("distage/distage-core")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -1979,6 +2179,26 @@ lazy val `distage-extension-config` = project.in(file("distage/distage-extension s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2079,27 +2299,7 @@ lazy val `distage-extension-config` = project.in(file("distage/distage-extension "-opt-inline-from:izumi.**" ) case (_, _) => Seq.empty - } }, - Compile / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Compile / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - }, - Test / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Test / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - } + } } ) .disablePlugins(AssemblyPlugin) @@ -2143,6 +2343,26 @@ lazy val `distage-extension-logstage` = project.in(file("distage/distage-extensi s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2288,6 +2508,26 @@ lazy val `distage-extension-plugins` = project.in(file("distage/distage-extensio s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2441,6 +2681,26 @@ lazy val `distage-framework` = project.in(file("distage/distage-framework")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2541,27 +2801,7 @@ lazy val `distage-framework` = project.in(file("distage/distage-framework")) "-opt-inline-from:izumi.**" ) case (_, _) => Seq.empty - } }, - Compile / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Compile / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - }, - Test / unmanagedSourceDirectories ++= { - val version = scalaVersion.value - val crossVersions = crossScalaVersions.value - import Ordering.Implicits._ - val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten - (Test / unmanagedSourceDirectories).value.flatMap { - case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } - case _ => Seq.empty - } - } + } } ) .disablePlugins(AssemblyPlugin) @@ -2611,6 +2851,26 @@ lazy val `distage-framework-docker` = project.in(file("distage/distage-framework s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2751,6 +3011,26 @@ lazy val `distage-testkit-core` = project.in(file("distage/distage-testkit-core" s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -2900,6 +3180,26 @@ lazy val `distage-testkit-scalatest` = project.in(file("distage/distage-testkit- s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3047,6 +3347,26 @@ lazy val `logstage-core` = project.in(file("logstage/logstage-core")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3193,6 +3513,26 @@ lazy val `logstage-rendering-circe` = project.in(file("logstage/logstage-renderi s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3334,6 +3674,26 @@ lazy val `logstage-adapter-slf4j` = project.in(file("logstage/logstage-adapter-s s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3479,6 +3839,26 @@ lazy val `logstage-sink-slf4j` = project.in(file("logstage/logstage-sink-slf4j") s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3648,6 +4028,26 @@ lazy val `microsite` = project.in(file("doc/microsite")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( @@ -3847,6 +4247,26 @@ lazy val `sbt-izumi-deps` = project.in(file("sbt-plugins/sbt-izumi-deps")) s"-Xmacro-settings:scala-version=${scalaVersion.value}", s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}" ), + Compile / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Compile / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, + Test / unmanagedSourceDirectories ++= { + val version = scalaVersion.value + val crossVersions = crossScalaVersions.value + import Ordering.Implicits._ + val ltEqVersions = crossVersions.map(CrossVersion.partialVersion).filter(_ <= CrossVersion.partialVersion(version)).flatten + (Test / unmanagedSourceDirectories).value.flatMap { + case dir if dir.getPath.endsWith("scala") => ltEqVersions.map { case (m, n) => file(dir.getPath + s"-$m.$n+") } + case _ => Seq.empty + } + }, Test / testOptions += Tests.Argument("-oDF"), scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match { case (_, "2.12.16") => Seq( diff --git a/fundamentals/fundamentals-bio/src/main/scala-2.13/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala b/fundamentals/fundamentals-bio/src/main/scala-2.13+/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala similarity index 100% rename from fundamentals/fundamentals-bio/src/main/scala-2.13/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala rename to fundamentals/fundamentals-bio/src/main/scala-2.13+/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala diff --git a/fundamentals/fundamentals-bio/src/main/scala-3/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala b/fundamentals/fundamentals-bio/src/main/scala-3/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala deleted file mode 100644 index ae687b0c55..0000000000 --- a/fundamentals/fundamentals-bio/src/main/scala-3/izumi/functional/bio/__VersionSpecificDurationConvertersCompat.scala +++ /dev/null @@ -1,11 +0,0 @@ -package izumi.functional.bio - -import scala.jdk.DurationConverters.JavaDurationOps - -private[bio] object __VersionSpecificDurationConvertersCompat { - - @inline private[bio] final def toFiniteDuration(duration: java.time.Duration): scala.concurrent.duration.FiniteDuration = { - duration.toScala - } - -} diff --git a/project/Deps.sc b/project/Deps.sc index 7df69725f4..5346ddd945 100644 --- a/project/Deps.sc +++ b/project/Deps.sc @@ -226,6 +226,8 @@ object Izumi { // .root.id.value}")).value.toPath().relativize(baseDirectory.value.toPath)).toFile""".raw ) + final val crossScalaSources = Defaults.CrossScalaPlusSources + final val topLevelSettings = Seq() final val sharedAggSettings = outOfSource ++ Seq( @@ -264,7 +266,7 @@ object Izumi { "libraryDependencies" += s""""io.7mind.izumi.sbt" % "sbtgen_2.13" % "${Version.SbtGen.value}" % Provided""".raw, ) - final val sharedSettings = Defaults.SbtMetaSharedOptions ++ outOfSource ++ Seq( + final val sharedSettings = Defaults.SbtMetaSharedOptions ++ outOfSource ++ crossScalaSources ++ Seq( "testOptions" in SettingScope.Test += """Tests.Argument("-oDF")""".raw, "scalacOptions" ++= Seq( SettingKey(Some(scala212), None) := Seq[Const]("-Wconf:any:error") ++ Defaults.Scala212Options, @@ -374,8 +376,6 @@ object Izumi { "fork" in (SettingScope.Test, Platform.Jvm) := true ) - final val crossScalaSources = Defaults.CrossScalaPlusSources - final lazy val fundamentals = Aggregate( name = Projects.fundamentals.id, artifacts = Seq( @@ -391,7 +391,7 @@ object Izumi { depends = Seq( Projects.fundamentals.functional ), - settings = crossScalaSources, + settings = Seq.empty, ), Artifact( name = Projects.fundamentals.literals, @@ -414,7 +414,7 @@ object Izumi { depends = Seq( Projects.fundamentals.literals ), - settings = crossScalaSources, + settings = Seq.empty, plugins = Plugins(Seq(Plugin("ScalaJSBundlerPlugin", Platform.Js))), ), Artifact( @@ -451,7 +451,7 @@ object Izumi { Projects.fundamentals.platform, Projects.fundamentals.functional, ), - settings = crossScalaSources, + settings = Seq.empty, ), Artifact( name = Projects.fundamentals.bio, @@ -514,7 +514,7 @@ object Izumi { depends = Seq(Projects.distage.coreApi).map(_ in Scope.Compile.all) ++ Seq(Projects.distage.core).map(_ in Scope.Test.all), platforms = Targets.jvm3, - settings = crossScalaSources, + settings = Seq.empty, ), Artifact( name = Projects.distage.extensionLogstage, @@ -539,7 +539,7 @@ object Izumi { Seq(Projects.distage.core, Projects.distage.frameworkApi, Projects.distage.plugins, Projects.distage.config).map(_ in Scope.Compile.all) ++ Seq(Projects.distage.plugins).map(_ tin Scope.Compile.all), platforms = Targets.jvm3, - settings = crossScalaSources, + settings = Seq.empty, ), Artifact( name = Projects.distage.docker,