Repository: 7mind/izumi
Pull request #714 (2019-11-04 20:12:48)

Add ImplDef disambiguator directly onto DIKey.SetElementKey


Patch:
diff --git a/build.sbt b/build.sbt
index 90240a427..4ec2625b4 100644
--- a/build.sbt
+++ b/build.sbt
@@ -59,43 +59,6 @@ lazy val `fundamentals-collections` = project.in(file("fundamentals/fundamentals
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -180,43 +143,6 @@ lazy val `fundamentals-platform` = project.in(file("fundamentals/fundamentals-pl
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -297,43 +223,6 @@ lazy val `fundamentals-functional` = project.in(file("fundamentals/fundamentals-
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -417,43 +306,6 @@ lazy val `fundamentals-bio` = project.in(file("fundamentals/fundamentals-bio"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -542,43 +394,6 @@ lazy val `fundamentals-typesafe-config` = project.in(file("fundamentals/fundamen
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -665,43 +480,6 @@ lazy val `fundamentals-reflection` = project.in(file("fundamentals/fundamentals-
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -793,43 +571,6 @@ lazy val `fundamentals-json-circe` = project.in(file("fundamentals/fundamentals-
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -921,44 +662,7 @@ lazy val `distage-model` = project.in(file("distage/distage-model"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.13.1") => Seq(
+      case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
         "8",
@@ -1042,43 +746,6 @@ lazy val `distage-proxy-cglib` = project.in(file("distage/distage-proxy-cglib"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1164,43 +831,6 @@ lazy val `distage-core` = project.in(file("distage/distage-core"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1287,43 +917,6 @@ lazy val `distage-config` = project.in(file("distage/distage-config"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1407,43 +1000,6 @@ lazy val `distage-roles-api` = project.in(file("distage/distage-roles-api"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1531,43 +1087,6 @@ lazy val `distage-plugins` = project.in(file("distage/distage-plugins"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1660,43 +1179,6 @@ lazy val `distage-roles` = project.in(file("distage/distage-roles"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -1789,44 +1271,7 @@ lazy val `distage-testkit` = project.in(file("distage/distage-testkit"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.13.1") => Seq(
+      case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
         "8",
@@ -1911,43 +1356,6 @@ lazy val `logstage-api` = project.in(file("logstage/logstage-api"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2038,43 +1446,6 @@ lazy val `logstage-core` = project.in(file("logstage/logstage-core"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2159,43 +1530,6 @@ lazy val `logstage-rendering-circe` = project.in(file("logstage/logstage-renderi
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2283,43 +1617,6 @@ lazy val `logstage-di` = project.in(file("logstage/logstage-di"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2404,43 +1701,6 @@ lazy val `logstage-config` = project.in(file("logstage/logstage-config"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2528,43 +1788,6 @@ lazy val `logstage-adapter-slf4j` = project.in(file("logstage/logstage-adapter-s
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2651,44 +1874,7 @@ lazy val `logstage-sink-slf4j` = project.in(file("logstage/logstage-sink-slf4j")
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.13.1") => Seq(
+      case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
         "8",
@@ -2773,43 +1959,6 @@ lazy val `idealingua-v1-model` = project.in(file("idealingua-v1/idealingua-v1-mo
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -2895,43 +2044,6 @@ lazy val `idealingua-v1-core` = project.in(file("idealingua-v1/idealingua-v1-cor
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3021,43 +2133,6 @@ lazy val `idealingua-v1-runtime-rpc-scala` = project.in(file("idealingua-v1/idea
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3149,43 +2224,6 @@ lazy val `idealingua-v1-runtime-rpc-http4s` = project.in(file("idealingua-v1/ide
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3226,179 +2264,21 @@ lazy val `idealingua-v1-transpilers` = project.in(file("idealingua-v1/idealingua
       "org.scalatest" %% "scalatest" % V.scalatest % Test,
       "org.scala-lang.modules" %% "scala-xml" % V.scala_xml,
       "org.scalameta" %% "scalameta" % V.scalameta
-    )
-  )
-  .settings(
-    organization := "io.7mind.izumi",
-    unmanagedSourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/scala" ,
-    unmanagedResourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/resources" ,
-    unmanagedSourceDirectories in Test += baseDirectory.value / ".jvm/src/test/scala" ,
-    unmanagedResourceDirectories in Test += baseDirectory.value / ".jvm/src/test/resources" ,
-    scalacOptions ++= Seq(
-      s"-Xmacro-settings:scala-version=${scalaVersion.value}",
-      s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}"
-    ),
-    testOptions in Test += Tests.Argument("-oDF"),
-    scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match {
-      case (_, "2.12.10") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.13.1") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Xlint:_",
-        "-Wunused:_",
-        "-Wdead-code",
-        "-Wextra-implicit",
-        "-Wnumeric-widen",
-        "-Woctal-literal",
-        "-Wvalue-discard"
-      )
-      case (_, _) => Seq.empty
-    } },
-    scalaVersion := crossScalaVersions.value.head,
-    crossScalaVersions := Seq(
-      "2.12.10",
-      "2.13.1"
-    ),
-    fork in Test := true
-  )
-  .disablePlugins(AssemblyPlugin)
-
-lazy val `idealingua-v1-test-defs` = project.in(file("idealingua-v1/idealingua-v1-test-defs"))
-  .dependsOn(
-    `idealingua-v1-runtime-rpc-scala` % "test->compile;compile->compile"
-  )
-  .settings(
-    libraryDependencies ++= Seq(
-      compilerPlugin("org.typelevel" % "kind-projector" % V.kind_projector cross CrossVersion.full),
-      "org.scala-lang.modules" %% "scala-collection-compat" % V.collection_compat,
-      "org.scalatest" %% "scalatest" % V.scalatest % Test
-    )
-  )
-  .settings(
-    organization := "io.7mind.izumi",
-    unmanagedSourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/scala" ,
-    unmanagedResourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/resources" ,
-    unmanagedSourceDirectories in Test += baseDirectory.value / ".jvm/src/test/scala" ,
-    unmanagedResourceDirectories in Test += baseDirectory.value / ".jvm/src/test/resources" ,
-    scalacOptions ++= Seq(
-      s"-Xmacro-settings:scala-version=${scalaVersion.value}",
-      s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}"
-    ),
-    testOptions in Test += Tests.Argument("-oDF"),
-    scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match {
-      case (_, "2.12.10") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
-      case (_, "2.12.8") => Seq(
+    )
+  )
+  .settings(
+    organization := "io.7mind.izumi",
+    unmanagedSourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/scala" ,
+    unmanagedResourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/resources" ,
+    unmanagedSourceDirectories in Test += baseDirectory.value / ".jvm/src/test/scala" ,
+    unmanagedResourceDirectories in Test += baseDirectory.value / ".jvm/src/test/resources" ,
+    scalacOptions ++= Seq(
+      s"-Xmacro-settings:scala-version=${scalaVersion.value}",
+      s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}"
+    ),
+    testOptions in Test += Tests.Argument("-oDF"),
+    scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match {
+      case (_, "2.12.10") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
         "8",
@@ -3454,11 +2334,15 @@ lazy val `idealingua-v1-test-defs` = project.in(file("idealingua-v1/idealingua-v
     crossScalaVersions := Seq(
       "2.12.10",
       "2.13.1"
-    )
+    ),
+    fork in Test := true
   )
   .disablePlugins(AssemblyPlugin)
 
-lazy val `idealingua-v1-runtime-rpc-typescript` = project.in(file("idealingua-v1/idealingua-v1-runtime-rpc-typescript"))
+lazy val `idealingua-v1-test-defs` = project.in(file("idealingua-v1/idealingua-v1-test-defs"))
+  .dependsOn(
+    `idealingua-v1-runtime-rpc-scala` % "test->compile;compile->compile"
+  )
   .settings(
     libraryDependencies ++= Seq(
       compilerPlugin("org.typelevel" % "kind-projector" % V.kind_projector cross CrossVersion.full),
@@ -3515,7 +2399,50 @@ lazy val `idealingua-v1-runtime-rpc-typescript` = project.in(file("idealingua-v1
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
+      case (_, "2.13.1") => Seq(
+        "-Xsource:2.13",
+        "-Ybackend-parallelism",
+        "8",
+        "-explaintypes",
+        "-Xlint:_",
+        "-Wunused:_",
+        "-Wdead-code",
+        "-Wextra-implicit",
+        "-Wnumeric-widen",
+        "-Woctal-literal",
+        "-Wvalue-discard"
+      )
+      case (_, _) => Seq.empty
+    } },
+    scalaVersion := crossScalaVersions.value.head,
+    crossScalaVersions := Seq(
+      "2.12.10",
+      "2.13.1"
+    )
+  )
+  .disablePlugins(AssemblyPlugin)
+
+lazy val `idealingua-v1-runtime-rpc-typescript` = project.in(file("idealingua-v1/idealingua-v1-runtime-rpc-typescript"))
+  .settings(
+    libraryDependencies ++= Seq(
+      compilerPlugin("org.typelevel" % "kind-projector" % V.kind_projector cross CrossVersion.full),
+      "org.scala-lang.modules" %% "scala-collection-compat" % V.collection_compat,
+      "org.scalatest" %% "scalatest" % V.scalatest % Test
+    )
+  )
+  .settings(
+    organization := "io.7mind.izumi",
+    unmanagedSourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/scala" ,
+    unmanagedResourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/resources" ,
+    unmanagedSourceDirectories in Test += baseDirectory.value / ".jvm/src/test/scala" ,
+    unmanagedResourceDirectories in Test += baseDirectory.value / ".jvm/src/test/resources" ,
+    scalacOptions ++= Seq(
+      s"-Xmacro-settings:scala-version=${scalaVersion.value}",
+      s"-Xmacro-settings:scala-versions=${crossScalaVersions.value.mkString(":")}"
+    ),
+    testOptions in Test += Tests.Argument("-oDF"),
+    scalacOptions ++= { (isSnapshot.value, scalaVersion.value) match {
+      case (_, "2.12.10") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
         "8",
@@ -3632,43 +2559,6 @@ lazy val `idealingua-v1-runtime-rpc-go` = project.in(file("idealingua-v1/idealin
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3749,43 +2639,6 @@ lazy val `idealingua-v1-runtime-rpc-csharp` = project.in(file("idealingua-v1/ide
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3888,43 +2741,6 @@ lazy val `idealingua-v1-compiler` = project.in(file("idealingua-v1/idealingua-v1
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -3994,10 +2810,6 @@ lazy val `microsite` = project.in(file("doc/microsite"))
     unmanagedResourceDirectories in Compile += baseDirectory.value / ".jvm/src/main/resources" ,
     unmanagedSourceDirectories in Test += baseDirectory.value / ".jvm/src/test/scala" ,
     unmanagedResourceDirectories in Test += baseDirectory.value / ".jvm/src/test/resources" ,
-    crossScalaVersions := Seq(
-      "2.12.8"
-    ),
-    scalaVersion := crossScalaVersions.value.head,
     coverageEnabled := false,
     skip in publish := true,
     DocKeys.prefix := {if (isSnapshot.value) {
@@ -4089,43 +2901,6 @@ lazy val `microsite` = project.in(file("doc/microsite"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -4143,7 +2918,8 @@ lazy val `microsite` = project.in(file("doc/microsite"))
     } },
     scalaVersion := crossScalaVersions.value.head,
     crossScalaVersions := Seq(
-      "2.12.8"
+      "2.12.10",
+      "2.13.1"
     )
   )
   .enablePlugins(ScalaUnidocPlugin, ParadoxSitePlugin, SitePlugin, GhpagesPlugin, ParadoxMaterialThemePlugin, PreprocessPlugin, MdocPlugin)
@@ -4208,43 +2984,6 @@ lazy val `sbt-izumi-deps` = project.in(file("sbt-plugins/sbt-izumi-deps"))
         "-Ywarn-unused-import",
         "-Ywarn-value-discard"
       )
-      case (_, "2.12.8") => Seq(
-        "-Xsource:2.13",
-        "-Ybackend-parallelism",
-        "8",
-        "-explaintypes",
-        "-Ypartial-unification",
-        "-Yno-adapted-args",
-        "-Xlint:adapted-args",
-        "-Xlint:by-name-right-associative",
-        "-Xlint:constant",
-        "-Xlint:delayedinit-select",
-        "-Xlint:doc-detached",
-        "-Xlint:inaccessible",
-        "-Xlint:infer-any",
-        "-Xlint:missing-interpolator",
-        "-Xlint:nullary-override",
-        "-Xlint:nullary-unit",
-        "-Xlint:option-implicit",
-        "-Xlint:package-object-classes",
-        "-Xlint:poly-implicit-overload",
-        "-Xlint:private-shadow",
-        "-Xlint:stars-align",
-        "-Xlint:type-parameter-shadow",
-        "-Xlint:unsound-match",
-        "-opt-warnings:_",
-        "-Ywarn-extra-implicit",
-        "-Ywarn-unused:_",
-        "-Ywarn-adapted-args",
-        "-Ywarn-dead-code",
-        "-Ywarn-inaccessible",
-        "-Ywarn-infer-any",
-        "-Ywarn-nullary-override",
-        "-Ywarn-nullary-unit",
-        "-Ywarn-numeric-widen",
-        "-Ywarn-unused-import",
-        "-Ywarn-value-discard"
-      )
       case (_, "2.13.1") => Seq(
         "-Xsource:2.13",
         "-Ybackend-parallelism",
@@ -4440,7 +3179,8 @@ lazy val `doc` = (project in file(".agg/doc-doc"))
   .settings(
     skip in publish := true,
     crossScalaVersions := Seq(
-      "2.12.8"
+      "2.12.10",
+      "2.13.1"
     ),
     scalaVersion := crossScalaVersions.value.head
   )
@@ -4453,7 +3193,8 @@ lazy val `doc-jvm` = (project in file(".agg/doc-doc-jvm"))
   .settings(
     skip in publish := true,
     crossScalaVersions := Seq(
-      "2.12.8"
+      "2.12.10",
+      "2.13.1"
     ),
     scalaVersion := crossScalaVersions.value.head
   )
@@ -4547,7 +3288,6 @@ lazy val `izumi` = (project in file("."))
               Developer(id = "7mind", name = "Septimal Mind", url = url("https://github.com/7mind"), email = "team@7mind.io"),
             ),
     scmInfo in ThisBuild := Some(ScmInfo(url("https://github.com/7mind/izumi"), "scm:git:https://github.com/7mind/izumi.git")),
-    scalacOptions in ThisBuild ++= Seq("-Ybackend-parallelism", math.max(1, sys.runtime.availableProcessors() - 1).toString),
     scalacOptions in ThisBuild += """-Xmacro-settings:scalatest-version=VExpr(V.scalatest)"""
   )
   .disablePlugins(AssemblyPlugin)
diff --git a/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala b/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
index ed9b2628d..a9bc3bb78 100644
--- a/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
+++ b/distage/distage-core/src/main/scala/izumi/distage/bootstrap/BootstrapLocator.scala
@@ -2,6 +2,8 @@ package izumi.distage.bootstrap
 
 import java.util.concurrent.atomic.AtomicReference
 
+import distage.TagK
+import izumi.distage._
 import izumi.distage.commons.{TraitInitTool, UnboxingTool}
 import izumi.distage.model._
 import izumi.distage.model.definition.{BootstrapContextModule, BootstrapContextModuleDef}
@@ -19,28 +21,21 @@ import izumi.distage.planning.gc.{NoopDIGC, TracingDIGC}
 import izumi.distage.provisioning._
 import izumi.distage.provisioning.strategies._
 import izumi.distage.reflection._
-import izumi.distage.{provisioning, _}
 import izumi.fundamentals.platform.console.TrivialLogger
 import izumi.fundamentals.platform.functional.Identity
-import distage.TagK
 
 final class BootstrapLocator(bindings: BootstrapContextModule) extends AbstractLocator {
-
-  import BootstrapLocator.{bootstrapPlanner, bootstrapProducer}
-
-  val parent: Option[AbstractLocator] = None
-
-  val plan: OrderedPlan = bootstrapPlanner.plan(PlannerInput.noGc(bindings))
+  override val parent: Option[AbstractLocator] = None
+  override val plan: OrderedPlan = BootstrapLocator.bootstrapPlanner.plan(PlannerInput.noGc(bindings))
+  override lazy val index: Map[RuntimeDIUniverse.DIKey, Any] = super.index
 
   private val bootstrappedContext: Locator = {
-    val resource = bootstrapProducer.instantiate[Identity](plan, this, FinalizersFilter.all)
+    val resource = BootstrapLocator.bootstrapProducer.instantiate[Identity](plan, this, FinalizersFilter.all)
     resource.extract(resource.acquire).throwOnFailure()
   }
 
   private val _instances = new AtomicReference[collection.Seq[IdentifiedRef]](bootstrappedContext.instances)
 
-  override lazy val index: Map[RuntimeDIUniverse.DIKey, Any] = super.index
-
   override def instances: collection.Seq[IdentifiedRef] = {
     Option(_instances.get()) match {
       case Some(value) =>
@@ -66,8 +61,8 @@ object BootstrapLocator {
   final val symbolIntrospector: SymbolIntrospectorDefaultImpl.Runtime = new SymbolIntrospectorDefaultImpl.Runtime
 
   final val reflectionProvider: ReflectionProviderDefaultImpl.Runtime = new ReflectionProviderDefaultImpl.Runtime(
-    new DependencyKeyProviderDefaultImpl.Runtime(symbolIntrospector)
-    , symbolIntrospector
+    keyProvider = new DependencyKeyProviderDefaultImpl.Runtime(symbolIntrospector),
+    symbolIntrospector = symbolIntrospector,
   )
 
   final val mirrorProvider: MirrorProvider.Impl.type = MirrorProvider.Impl
@@ -83,39 +78,36 @@ object BootstrapLocator {
     val hook = new PlanningHookAggregate(Set.empty)
     val translator = new BindingTranslatorImpl(reflectionProvider, hook)
     new PlannerDefaultImpl(
-      new ForwardingRefResolverDefaultImpl(analyzer, reflectionProvider, true),
-      new SanityCheckerDefaultImpl(analyzer),
-      NoopDIGC,
-      bootstrapObserver,
-      new PlanMergingPolicyDefaultImpl,
-      hook,
-      translator,
-      analyzer,
-      symbolIntrospector,
+      forwardingRefResolver = new ForwardingRefResolverDefaultImpl(analyzer, reflectionProvider, true),
+      sanityChecker = new SanityCheckerDefaultImpl(analyzer),
+      gc = NoopDIGC,
+      planningObserver = bootstrapObserver,
+      planMergingPolicy = new PlanMergingPolicyDefaultImpl,
+      hook = hook,
+      bindingTranslator = translator,
+      analyzer = analyzer,
+      symbolIntrospector = symbolIntrospector,
     )
   }
 
   final val bootstrapProducer: PlanInterpreter = {
     val loggerHook = new LoggerHookDefaultImpl // TODO: add user-controllable logs
     val unboxingTool = new UnboxingTool(mirrorProvider)
-    val verifier = new provisioning.ProvisionOperationVerifier.Default(mirrorProvider, unboxingTool)
+    val verifier = new ProvisionOperationVerifier.Default(mirrorProvider, unboxingTool)
     new PlanInterpreterDefaultRuntimeImpl(
-      new SetStrategyDefaultImpl(verifier)
-
-      , new ProxyStrategyFailingImpl
-      , new FactoryStrategyFailingImpl
-      , new TraitStrategyFailingImpl
-
-      , new FactoryProviderStrategyDefaultImpl(loggerHook)
-      , new ProviderStrategyDefaultImpl
-      , new ClassStrategyDefaultImpl(symbolIntrospector, mirrorProvider, unboxingTool)
-      , new ImportStrategyDefaultImpl
-      , new InstanceStrategyDefaultImpl
-      , new EffectStrategyDefaultImpl
-      , new ResourceStrategyDefaultImpl
-
-      , new ProvisioningFailureInterceptorDefaultImpl
-      , verifier
+      setStrategy = new SetStrategyDefaultImpl,
+      proxyStrategy = new ProxyStrategyFailingImpl,
+      factoryStrategy = new FactoryStrategyFailingImpl,
+      traitStrategy = new TraitStrategyFailingImpl,
+      factoryProviderStrategy = new FactoryProviderStrategyDefaultImpl(loggerHook),
+      providerStrategy = new ProviderStrategyDefaultImpl,
+      classStrategy = new ClassStrategyDefaultImpl(symbolIntrospector, mirrorProvider, unboxingTool),
+      importStrategy = new ImportStrategyDefaultImpl,
+      instanceStrategy = new InstanceStrategyDefaultImpl,
+      effectStrategy = new EffectStrategyDefaultImpl,
+      resourceStrategy = new ResourceStrategyDefaultImpl,
+      failureHandler = new ProvisioningFailureInterceptorDefaultImpl,
+      verifier = verifier,
     )
   }
 
@@ -139,7 +131,7 @@ object BootstrapLocator {
 
     make[PlanAnalyzer].from[PlanAnalyzerDefaultImpl]
     make[PlanMergingPolicy].from[PlanMergingPolicyDefaultImpl]
-    make[Boolean].named("distage.init-proxies-asap").from(true)
+    make[Boolean].named("distage.init-proxies-asap").fromValue(true)
     make[ForwardingRefResolver].from[ForwardingRefResolverDefaultImpl]
     make[SanityChecker].from[SanityCheckerDefaultImpl]
     make[Planner].from[PlannerDefaultImpl]
diff --git a/distage/distage-core/src/main/scala/izumi/distage/planning/AssignableFromAutoSetHook.scala b/distage/distage-core/src/main/scala/izumi/distage/planning/AssignableFromAutoSetHook.scala
index 1ca5b7bb2..64bcc85ec 100644
--- a/distage/distage-core/src/main/scala/izumi/distage/planning/AssignableFromAutoSetHook.scala
+++ b/distage/distage-core/src/main/scala/izumi/distage/planning/AssignableFromAutoSetHook.scala
@@ -1,5 +1,6 @@
 package izumi.distage.planning
 
+import izumi.distage.model.definition.ImplDef
 import izumi.distage.model.plan.{ExecutableOp, OrderedPlan, SemiPlan}
 import izumi.distage.model.planning.PlanningHook
 import izumi.distage.model.providers.ProviderMagnet
@@ -96,8 +97,8 @@ class AssignableFromAutoSetHook[INSTANCE: Tag, BINDING: Tag](private val wrap: I
               newMembers += op.target
               Seq(op)
             } else {
-              val newKey = DIKey.SetElementKey(setKey, op.target)
               val provider = ProviderMagnet(wrap).get
+              val newKey = DIKey.SetElementKey(setKey, op.target, Some(ImplDef.ProviderImpl(op.target.tpe, provider)))
               val newOp = ExecutableOp.WiringOp.CallProvider(newKey, Wiring.SingletonWiring.Function(provider, provider.associations), op.origin)
               newMembers += newKey
               Seq(op, newOp)
@@ -108,7 +109,7 @@ class AssignableFromAutoSetHook[INSTANCE: Tag, BINDING: Tag](private val wrap: I
         }
     }
 
-    val newSetKeys: scala.collection.immutable.Set[DIKey] = ListSet.newBuilder.++=(newMembers).result()
+    val newSetKeys = ListSet.newBuilder.++=(newMembers).result()
     val newSetOp = ExecutableOp.CreateSet(setKey, setKey.tpe, newSetKeys, None)
 
     plan.copy(steps = newSteps :+ newSetOp)
diff --git a/distage/distage-core/src/main/scala/izumi/distage/provisioning/strategies/SetStrategyDefaultImpl.scala b/distage/distage-core/src/main/scala/izumi/distage/provisioning/strategies/SetStrategyDefaultImpl.scala
index 8143d3f48..d7972411b 100644
--- a/distage/distage-core/src/main/scala/izumi/distage/provisioning/strategies/SetStrategyDefaultImpl.scala
+++ b/distage/distage-core/src/main/scala/izumi/distage/provisioning/strategies/SetStrategyDefaultImpl.scala
@@ -5,14 +5,10 @@ import izumi.distage.model.plan.ExecutableOp.CreateSet
 import izumi.distage.model.provisioning.strategies.SetStrategy
 import izumi.distage.model.provisioning.{NewObjectOp, ProvisioningKeyProvider}
 import izumi.distage.model.reflection.universe.RuntimeDIUniverse._
-import izumi.distage.provisioning.ProvisionOperationVerifier
 
 import scala.collection.immutable.ListSet
 
-class SetStrategyDefaultImpl
-(
-  verifier: ProvisionOperationVerifier,
-) extends SetStrategy {
+class SetStrategyDefaultImpl extends SetStrategy {
   def makeSet(context: ProvisioningKeyProvider, op: CreateSet): Seq[NewObjectOp.NewInstance] = {
     // target is guaranteed to be a Set
     val scalaCollectionSetType = SafeType.get[collection.Set[_]]
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/definition/Binding.scala b/distage/distage-model/src/main/scala/izumi/distage/model/definition/Binding.scala
index afb050b0e..7a3feae8f 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/definition/Binding.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/definition/Binding.scala
@@ -2,7 +2,6 @@ package izumi.distage.model.definition
 
 import izumi.distage.model.definition.Binding.GroupingKey
 import izumi.distage.model.providers.ProviderMagnet
-import izumi.distage.model.reflection
 import izumi.distage.model.reflection.universe.RuntimeDIUniverse
 import izumi.distage.model.reflection.universe.RuntimeDIUniverse._
 import izumi.fundamentals.platform.language.SourceFilePosition
@@ -59,32 +58,7 @@ object Binding {
   }
 
   final case class SetElementBinding(key: DIKey.SetElementKey, implementation: ImplDef, tags: Set[BindingTag], origin: SourceFilePosition) extends ImplBinding with SetBinding {
-    override lazy val group: GroupingKey = {
-      def fixSetKey(k: DIKey.SetElementKey): DIKey.SetElementKey = {
-        k.reference match {
-          case id: DIKey.IdKey[_] =>
-            DIKey.SetElementKey(key.set, fixKey(id))
-          case _ =>
-            k
-        }
-      }
-      def fixKey(k: DIKey): reflection.universe.RuntimeDIUniverse.DIKey = {
-        k match {
-          case id: DIKey.IdKey[_] =>
-            id.id match {
-              case _: DIKey.SetLocId =>
-                DIKey.TypeKey(id.tpe)
-              case _ =>
-                k
-            }
-          case _ =>
-            k
-        }
-      }
-
-      val gk = fixSetKey(key)
-      GroupingKey.KeyImpl(gk, implementation)
-    }
+    override def group: GroupingKey = GroupingKey.KeyImpl(key, implementation)
     override def withImplDef(implDef: ImplDef): SetElementBinding = copy(implementation = implDef)
     protected[this] def withTags(newTags: Set[BindingTag]): SetElementBinding = copy(tags = newTags)
     override def addTags(moreTags: Set[BindingTag]): SetElementBinding = withTags(this.tags ++ moreTags)
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/definition/Bindings.scala b/distage/distage-model/src/main/scala/izumi/distage/model/definition/Bindings.scala
index 7fd90d92f..d267bd9f5 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/definition/Bindings.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/definition/Bindings.scala
@@ -28,19 +28,22 @@ object Bindings {
   def setElement[T: Tag, I <: T: Tag](implicit pos: CodePositionMaterializer): SetElementBinding = {
     val setkey = DIKey.get[Set[T]]
     val implKey = DIKey.get[I]
-    SetElementBinding(DIKey.SetElementKey(setkey, implKey), ImplDef.TypeImpl(SafeType.get[I]), Set.empty, pos.get.position)
+    val implDef = ImplDef.TypeImpl(SafeType.get[I])
+    SetElementBinding(DIKey.SetElementKey(setkey, implKey, Some(implDef)), implDef, Set.empty, pos.get.position)
   }
 
   def setElement[T: Tag, I <: T: Tag](instance: I)(implicit pos: CodePositionMaterializer): SetElementBinding = {
     val setkey = DIKey.get[Set[T]]
-    val implKey = DIKey.get[I].named(DIKey.SetLocId(pos.get.toString, instance.hashCode()))
-    SetElementBinding(DIKey.SetElementKey(setkey, implKey), ImplDef.InstanceImpl(SafeType.get[I], instance), Set.empty, pos.get.position)
+    val implKey = DIKey.get[I]
+    val implDef = ImplDef.InstanceImpl(SafeType.get[I], instance)
+    SetElementBinding(DIKey.SetElementKey(setkey, implKey, Some(implDef)), implDef, Set.empty, pos.get.position)
   }
 
   def setElementProvider[T: Tag](function: ProviderMagnet[T])(implicit pos: CodePositionMaterializer): SetElementBinding = {
     val setkey = DIKey.get[Set[T]]
-    val implKey = DIKey.TypeKey(function.get.ret).named(DIKey.SetLocId(pos.get.toString, function.hashCode()))
-    SetElementBinding(DIKey.SetElementKey(setkey, implKey), ImplDef.ProviderImpl(function.get.ret, function.get), Set.empty, pos.get.position)
+    val implKey = DIKey.TypeKey(function.get.ret)
+    val implDef = ImplDef.ProviderImpl(function.get.ret, function.get)
+    SetElementBinding(DIKey.SetElementKey(setkey, implKey, Some(implDef)), implDef, Set.empty, pos.get.position)
   }
 
   def todo[K <: DIKey](key: K)(implicit pos: CodePositionMaterializer): SingletonBinding[K] = {
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/definition/dsl/AbstractBindingDefDSL.scala b/distage/distage-model/src/main/scala/izumi/distage/model/definition/dsl/AbstractBindingDefDSL.scala
index 924dbb53a..7cc9217de 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/definition/dsl/AbstractBindingDefDSL.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/definition/dsl/AbstractBindingDefDSL.scala
@@ -175,8 +175,7 @@ object AbstractBindingDefDSL {
   final class SetElementRef(implDef: ImplDef, pos: SourceFilePosition, ops: mutable.Queue[SetElementInstruction] = mutable.Queue.empty) {
     def interpret(setKey: DIKey.BasicKey): SetElementBinding = {
       val implKey = DIKey.TypeKey(implDef.implType)
-      val refkey = implKey.named(DIKey.SetLocId(pos.toString, implDef.hashCode()))
-      val elKey = DIKey.SetElementKey(setKey, refkey)
+      val elKey = DIKey.SetElementKey(setKey, implKey, Some(implDef))
 
       ops.foldLeft(SetElementBinding(elKey, implDef, Set.empty, pos)) {
         (b, instr) =>
@@ -194,12 +193,11 @@ object AbstractBindingDefDSL {
 
   final class MultiSetElementRef(implDef: ImplDef, pos: SourceFilePosition, ops: mutable.Queue[MultiSetElementInstruction] = mutable.Queue.empty) {
     def interpret(setKey: DIKey.BasicKey): Seq[Binding] = {
-      val ukey = DIKey.IdKey(implDef.implType, DIKey.SetImplId(implDef))
+      val valueProxyKey = DIKey.IdKey(implDef.implType, DIKey.MultiSetImplId(setKey, implDef))
+      val valueProxyBinding = SingletonBinding(valueProxyKey, implDef, Set.empty, pos)
 
-      val bind = SingletonBinding(ukey, implDef, Set.empty, pos)
-
-      val elKey = DIKey.SetElementKey(setKey, ukey)
-      val refBind0 = SetElementBinding(elKey, ImplDef.ReferenceImpl(bind.key.tpe, bind.key, weak = false), Set.empty, pos)
+      val elementKey = DIKey.SetElementKey(setKey, valueProxyKey, Some(implDef))
+      val refBind0 = SetElementBinding(elementKey, ImplDef.ReferenceImpl(valueProxyBinding.key.tpe, valueProxyBinding.key, weak = false), Set.empty, pos)
 
       val refBind = ops.foldLeft(refBind0) {
         (b, op) =>
@@ -208,7 +206,7 @@ object AbstractBindingDefDSL {
           }
       }
 
-      Seq(bind, refBind)
+      Seq(valueProxyBinding, refBind)
     }
 
     def append(op: MultiSetElementInstruction): MultiSetElementRef = {
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/plan/ExecutableOp.scala b/distage/distage-model/src/main/scala/izumi/distage/model/plan/ExecutableOp.scala
index b3c929608..1cba7dccf 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/plan/ExecutableOp.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/plan/ExecutableOp.scala
@@ -6,12 +6,13 @@ import izumi.distage.model.reflection.universe.RuntimeDIUniverse
 import izumi.distage.model.reflection.universe.RuntimeDIUniverse.Wiring._
 import izumi.distage.model.reflection.universe.RuntimeDIUniverse._
 
+import scala.annotation.tailrec
+
 sealed trait ExecutableOp {
   def target: DIKey
-
   def origin: Option[Binding]
 
-  override def toString: String = new OpFormatter.Impl(KeyFormatter.Full, TypeFormatter.Full).format(this)
+  override final def toString: String = new OpFormatter.Impl(KeyFormatter.Full, TypeFormatter.Full).format(this)
 }
 
 object ExecutableOp {
@@ -19,33 +20,22 @@ object ExecutableOp {
   sealed trait InstantiationOp extends ExecutableOp
 
   final case class ImportDependency(target: DIKey, references: Set[DIKey], origin: Option[Binding]) extends ExecutableOp
-
   final case class CreateSet(target: DIKey, element: SafeType, members: Set[DIKey], origin: Option[Binding]) extends InstantiationOp
 
   sealed trait WiringOp extends InstantiationOp {
     def target: DIKey
-
     def wiring: PureWiring
-
     def origin: Option[Binding]
   }
 
   object WiringOp {
-
     final case class InstantiateClass(target: DIKey, wiring: SingletonWiring.Constructor, origin: Option[Binding]) extends WiringOp
-
     final case class InstantiateTrait(target: DIKey, wiring: SingletonWiring.AbstractSymbol, origin: Option[Binding]) extends WiringOp
-
     final case class InstantiateFactory(target: DIKey, wiring: Factory, origin: Option[Binding]) extends WiringOp
-
     final case class CallProvider(target: DIKey, wiring: SingletonWiring.Function, origin: Option[Binding]) extends WiringOp
-
     final case class CallFactoryProvider(target: DIKey, wiring: FactoryFunction, origin: Option[Binding]) extends WiringOp
-
     final case class ReferenceInstance(target: DIKey, wiring: SingletonWiring.Instance, origin: Option[Binding]) extends WiringOp
-
     final case class ReferenceKey(target: DIKey, wiring: SingletonWiring.Reference, origin: Option[Binding]) extends WiringOp
-
   }
 
   sealed trait MonadicOp extends InstantiationOp {
@@ -54,11 +44,9 @@ object ExecutableOp {
   }
 
   object MonadicOp {
-
     final case class ExecuteEffect(target: DIKey, effectOp: WiringOp, wiring: Wiring.MonadicWiring.Effect, origin: Option[Binding]) extends MonadicOp {
       override def effectWiring: RuntimeDIUniverse.Wiring.PureWiring = wiring.effectWiring
     }
-
     final case class AllocateResource(target: DIKey, effectOp: WiringOp, wiring: Wiring.MonadicWiring.Resource, origin: Option[Binding]) extends MonadicOp {
       override def effectWiring: RuntimeDIUniverse.Wiring.PureWiring = wiring.effectWiring
     }
@@ -67,16 +55,13 @@ object ExecutableOp {
   sealed trait ProxyOp extends ExecutableOp
 
   object ProxyOp {
-
     final case class MakeProxy(op: InstantiationOp, forwardRefs: Set[DIKey], origin: Option[Binding], byNameAllowed: Boolean) extends ProxyOp {
       override def target: DIKey = op.target
     }
-
     final case class InitProxy(target: DIKey, dependencies: Set[DIKey], proxy: MakeProxy, origin: Option[Binding]) extends ProxyOp
-
   }
 
-  @scala.annotation.tailrec
+  @tailrec
   def instanceType(op: ExecutableOp): SafeType = {
     op match {
       case w: WiringOp =>
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/plan/KeyMinimizer.scala b/distage/distage-model/src/main/scala/izumi/distage/model/plan/KeyMinimizer.scala
index 0e9989393..825785302 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/plan/KeyMinimizer.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/plan/KeyMinimizer.scala
@@ -54,8 +54,8 @@ class KeyMinimizer(allKeys: Set[DIKey]) {
       case DIKey.ProxyElementKey(proxied, _) =>
         s"{proxy.${render(proxied)}}"
 
-      case DIKey.SetElementKey(set, reference) =>
-        s"{set.${render(set)}/${render(reference)}}"
+      case DIKey.SetElementKey(set, reference, disambiguator) =>
+        s"{set.${render(set)}/${render(reference)}#${disambiguator.fold("0")(_.hashCode().toString)}"
     }
   }
 
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/references/WithDIKey.scala b/distage/distage-model/src/main/scala/izumi/distage/model/references/WithDIKey.scala
index 81490e0ca..f190438ed 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/references/WithDIKey.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/references/WithDIKey.scala
@@ -43,23 +43,16 @@ trait WithDIKey {
       * @param set Key of the parent Set. `set.tpe` must be of type `Set[T]`
       * @param reference Key of `this` individual element. `reference.tpe` must be a subtype of `T`
       */
-    case class SetElementKey(set: DIKey, reference: DIKey) extends DIKey {
+    case class SetElementKey(set: DIKey, reference: DIKey, disambiguator: Option[ImplDef]) extends DIKey {
       override def tpe: SafeType = reference.tpe
 
-      override def toString: String = s"{set.$set/${reference.toString}}"
+      override def toString: String = s"{set.$set/${reference.toString}#${disambiguator.fold("0")(_.hashCode().toString)}"
     }
 
-    case class SetLocId(name: String, hash: Int)
-    object SetLocId {
-      implicit object SetLocIdContract extends IdContract[SetLocId] {
-        override def repr(v: SetLocId): String = s"set/${v.name}#${v.hash}"
-      }
-    }
-
-    case class SetImplId(impl: ImplDef)
-    object SetImplId {
-      implicit object SetImplIdContract extends IdContract[SetImplId] {
-        override def repr(v: SetImplId): String = "setimpl/"+v.toString
+    case class MultiSetImplId(set: DIKey, impl: ImplDef)
+    object MultiSetImplId {
+      implicit object SetImplIdContract extends IdContract[MultiSetImplId] {
+        override def repr(v: MultiSetImplId): String = s"set/${v.set}#${v.impl.hashCode()}"
       }
     }
   }
diff --git a/distage/distage-model/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala b/distage/distage-model/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
index e14579591..b0022a015 100644
--- a/distage/distage-model/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
+++ b/distage/distage-model/src/main/scala/izumi/distage/model/reflection/macros/DIUniverseLiftables.scala
@@ -46,41 +46,13 @@ abstract class DIUniverseLiftables[D <: StaticDIUniverse](val u: D) {
       q"""{ new $runtimeDIUniverse.DIKey.IdKey($tpe, ${lift(id)}) }"""
   }
 
-  implicit val liftableProxyElementKey: Liftable[DIKey.ProxyElementKey] = {
-    case DIKey.ProxyElementKey(proxied, symbol) => q"""
-    { new $runtimeDIUniverse.DIKey.ProxyElementKey(${liftableDIKey(proxied)}, $symbol) }
-      """
-  }
-
-  implicit val liftableSetElementKey: Liftable[DIKey.SetElementKey] = {
-    case DIKey.SetElementKey(set, ref) => q"""
-    { new $runtimeDIUniverse.DIKey.SetElementKey(${liftableDIKey(set)}, ${liftableDIKey(ref)}) }
-      """
-  }
-
   implicit val liftableBasicDIKey: Liftable[DIKey.BasicKey] = {
     Liftable[DIKey.BasicKey] {
-      d =>
-        (d: @unchecked) match {
-          case t: DIKey.TypeKey => q"$t"
-          case i: DIKey.IdKey[_] => q"${liftableIdKey(i)}"
-        }
+      case t: DIKey.TypeKey => q"$t"
+      case i: DIKey.IdKey[_] => q"${liftableIdKey(i)}"
     }
   }
 
-  implicit val liftableDIKey: Liftable[DIKey] = {
-    Liftable[DIKey] {
-      d =>
-        (d: @unchecked) match {
-          case t: DIKey.TypeKey => q"$t"
-          case t: DIKey.IdKey[_] => q"${t: DIKey.BasicKey}"
-          case p: DIKey.ProxyElementKey => q"$p"
-          case s: DIKey.SetElementKey => q"$s"
-        }
-    }
-  }
-
-
   // ParameterContext
 
   implicit val liftableConstructorParameterContext: Liftable[DependencyContext.ConstructorParameterContext] = {
diff --git a/distage/distage-roles/src/test/resources/check-test-good.conf b/distage/distage-plugins/src/test/resources/check-test-good.conf
similarity index 100%
rename from distage/distage-roles/src/test/resources/check-test-good.conf
rename to distage/distage-plugins/src/test/resources/check-test-good.conf
diff --git a/distage/distage-roles/src/main/scala/izumi/distage/roles/services/ResourceRewriter.scala b/distage/distage-roles/src/main/scala/izumi/distage/roles/services/ResourceRewriter.scala
index 20134780c..cf6f10ca6 100644
--- a/distage/distage-roles/src/main/scala/izumi/distage/roles/services/ResourceRewriter.scala
+++ b/distage/distage-roles/src/main/scala/izumi/distage/roles/services/ResourceRewriter.scala
@@ -88,11 +88,11 @@ class ResourceRewriter(
               val newImpl = function.unsafeMap(resourceType, (instance: Any) => convert(instance.asInstanceOf[TGT]))
               ReplaceImpl(ImplDef.ProviderImpl(resourceType, newImpl))
 
-            case ImplDef.TypeImpl(_) =>
+            case implDef@ImplDef.TypeImpl(_) =>
               val implTypeKey = DIKey.TypeKey(implType)
               val newKey = DIKey.IdKey(
                 tpe = implType,
-                id = ResId(if (set) DIKey.SetElementKey(key, implTypeKey) else implTypeKey)
+                id = ResId(if (set) DIKey.SetElementKey(key, implTypeKey, Some(implDef)) else implTypeKey)
               )
 
               val parameter = {


Test patch:
diff --git a/distage/distage-core/src/test/scala/izumi/distage/dsl/DSLTest.scala b/distage/distage-core/src/test/scala/izumi/distage/dsl/DSLTest.scala
index 959bb3613..87dbf57a2 100644
--- a/distage/distage-core/src/test/scala/izumi/distage/dsl/DSLTest.scala
+++ b/distage/distage-core/src/test/scala/izumi/distage/dsl/DSLTest.scala
@@ -3,7 +3,8 @@ package izumi.distage.dsl
 import distage._
 import izumi.distage.fixtures.BasicCases._
 import izumi.distage.fixtures.SetCases._
-import izumi.distage.model.definition.{BindingTag, Bindings, Module}
+import izumi.distage.model.definition.Binding.SetElementBinding
+import izumi.distage.model.definition.{BindingTag, Bindings, ImplDef, Module}
 import org.scalatest.WordSpec
 
 class DSLTest extends WordSpec {
@@ -199,7 +200,7 @@ class DSLTest extends WordSpec {
       assert(definition.bindings.count(_.tags.strings == Set("B")) == 1)
     }
 
-    "progression: multiset bindings should support tag merge" in {
+    "Multiset bindings support tag merge" in {
       import SetCase1._
 
 //      val set1 = Set(new SetImpl4, new SetImpl4)
@@ -218,6 +219,21 @@ class DSLTest extends WordSpec {
       assert(definition.bindings.count(_.tags.strings == Set("A", "B")) == 2)
     }
 
+    "Set bindings with the same source position but different implementations do not conflict" in {
+      val definition: ModuleDef = new ModuleDef {
+        def int(int: Int) = many[Int].addValue(int)
+
+        int(1)
+        int(2)
+        int(3)
+      }
+
+      assert(definition.bindings.size == 4)
+      assert(definition.bindings.collect {
+        case SetElementBinding(_, ImplDef.InstanceImpl(_, n: Int), _, _) => n
+      } == Set(1, 2, 3))
+    }
+
     "Tags in different modules are merged" in {
       import BasicCase1._
 
diff --git a/distage/distage-core/src/test/scala/izumi/distage/injector/AutoSetTest.scala b/distage/distage-core/src/test/scala/izumi/distage/injector/AutoSetTest.scala
index bd10e6663..ce78b64ac 100644
--- a/distage/distage-core/src/test/scala/izumi/distage/injector/AutoSetTest.scala
+++ b/distage/distage-core/src/test/scala/izumi/distage/injector/AutoSetTest.scala
@@ -6,6 +6,7 @@ import izumi.distage.model.PlannerInput
 import izumi.distage.model.planning.PlanningHook
 import izumi.distage.planning.AssignableFromAutoSetHook
 import distage.{BootstrapModuleDef, Injector, ModuleDef}
+import izumi.distage.fixtures.SetCases.SetCase3.{ServiceA, ServiceB, ServiceC, ServiceD}
 
 class AutoSetTest extends WordSpec with MkInjector {
 
@@ -25,9 +26,30 @@ class AutoSetTest extends WordSpec with MkInjector {
         .add(new AssignableFromAutoSetHook[Ordered, Ordered](identity))
     })
 
-    val autoCloseableSet = injector.produceUnsafe(PlannerInput.noGc(definition)).get[Set[Ordered]]
+    val autoset = injector.produceUnsafe(PlannerInput.noGc(definition)).get[Set[Ordered]]
 
-    assert(autoCloseableSet.toSeq == autoCloseableSet.toSeq.sortBy(_.order))
+    assert(autoset.toSeq == autoset.toSeq.sortBy(_.order))
+  }
+
+  "AutoSets collect instances with the same type but different implementations" in {
+    val definition = new ModuleDef {
+      make[Int].fromValue(1)
+      make[Int].named("x").fromValue(2)
+      many[Int].named("nonauto")
+        .addValue(3)
+        .addValue(4)
+        .addValue(5)
+    }
+
+    val injector = Injector.Standard(new BootstrapModuleDef {
+      many[AutoCloseable]
+      many[PlanningHook]
+        .add(new AssignableFromAutoSetHook[Int, Int](identity))
+    })
+
+    val autoset = injector.produceUnsafe(PlannerInput.noGc(definition)).get[Set[Int]]
+
+    assert(autoset == Set(1, 2, 3, 4, 5))
   }
 
 }
diff --git a/distage/distage-roles/src/test/scala/izumi/distage/roles/test/StaticPluginCheckerTest.scala b/distage/distage-roles/src/test/scala/izumi/distage/roles/test/StaticPluginCheckerTest.scala
index b6ea1d324..bb5be9fd5 100644
--- a/distage/distage-roles/src/test/scala/izumi/distage/roles/test/StaticPluginCheckerTest.scala
+++ b/distage/distage-roles/src/test/scala/izumi/distage/roles/test/StaticPluginCheckerTest.scala
@@ -6,14 +6,14 @@ import org.scalatest.WordSpec
 
 class StaticPluginCheckerTest extends WordSpec {
 
-  "Check when config & requirements are valid" in {
-    StaticPluginChecker.checkWithConfig[StaticTestPlugin, LogstageModuleRequirements]("test:x", ".*check-test-good.conf")
-  }
-
   "Check without config" in {
     StaticPluginChecker.check[StaticTestPlugin, LogstageModuleRequirements]("test:x")
   }
 
+  "Check when config & requirements are valid" in {
+    StaticPluginChecker.checkWithConfig[StaticTestPlugin, LogstageModuleRequirements]("test:x", ".*check-test-good.conf")
+  }
+
   "Check depending plugin with plugins" in {
     StaticPluginChecker.checkWithPlugins[DependingPlugin, LogstageModuleRequirements]("com.github.pshirshov.test.plugins", "test:x")
     StaticPluginChecker.checkWithPluginsConfig[DependingPlugin, LogstageModuleRequirements]("com.github.pshirshov.test.plugins", "test:x", ".*check-test-good.conf")