Merge pull request #1105 from joroKr21/bincompat

Binary compatible and cross compiling 2.3 version

Author: joroKr21

.github/workflows/ci.yml

@@ -9,9 +9,9 @@ name: Continuous Integration
 
 on:
   pull_request:
-    branches: ['*']
+    branches: ['**']
   push:
-    branches: ['*']
+    branches: ['**']
     tags: [v*]
 
 env:

build.sbt

@@ -1,11 +1,7 @@
-import com.typesafe.tools.mima.plugin.MimaPlugin.mimaDefaultSettings
-import com.typesafe.tools.mima.core._
+import com.typesafe.sbt.SbtGit.GitKeys._
 import com.typesafe.tools.mima.core.ProblemFilters._
-
-import com.typesafe.sbt.SbtGit._
-import GitKeys._
-
-import sbtcrossproject.CrossPlugin.autoImport.{CrossType, crossProject}
+import com.typesafe.tools.mima.core._
+import sbtcrossproject.CrossPlugin.autoImport.crossProject
 import sbtcrossproject.CrossProject
 
 val Scala211 = "2.11.12"
@@ -27,11 +23,10 @@ ThisBuild / githubWorkflowBuildPreamble := Seq(
   WorkflowStep.Run(List("sudo apt install clang libunwind-dev libgc-dev libre2-dev"))
 )
 ThisBuild / githubWorkflowJavaVersions := Seq("[email protected]")
-ThisBuild / githubWorkflowBuildMatrixAdditions +=
-  "platform" -> List("jvm", "js", "native")
-
 ThisBuild / githubWorkflowArtifactUpload := false
+ThisBuild / githubWorkflowBuildMatrixAdditions += "platform" -> List("jvm", "js", "native")
 ThisBuild / githubWorkflowBuildMatrixFailFast := Some(false)
+ThisBuild / githubWorkflowTargetBranches := Seq("**") // match all branches, including slashes
 
 val JvmCond = s"matrix.platform == 'jvm'"
 val JsCond = s"matrix.platform == 'js'"
@@ -167,14 +162,18 @@ lazy val CrossTypeMixed: sbtcrossproject.CrossType = new sbtcrossproject.CrossTy
     Some(projectBase.getParentFile / "src" / conf / "scala")
 }
 
+val boilerplate = Def.taskDyn {
+  (sourceManaged in Compile).map(Boilerplate.gen(scalaBinaryVersion.value))
+}
+
 lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform).crossType(CrossTypeMixed)
   .configureCross(configureJUnit)
   .settings(moduleName := "shapeless")
   .settings(coreSettings:_*)
   .configureCross(buildInfoSetup)
   .enablePlugins(SbtOsgi)
   .settings(coreOsgiSettings:_*)
-  .settings(sourceGenerators in Compile += (sourceManaged in Compile).map(Boilerplate.gen).taskValue)
+  .settings(sourceGenerators in Compile += boilerplate.taskValue)
   .settings(mimaSettings:_*)
   .jsSettings(commonJsSettings:_*)
   .jvmSettings(commonJvmSettings:_*)
@@ -312,68 +311,22 @@ lazy val noPublishSettings =
 
 enablePlugins(MimaPlugin)
 lazy val mimaSettings = Seq(
-  mimaPreviousArtifacts := {
-    val previousVersion = if(scalaVersion.value.startsWith("2.13.")) "2.3.3" else "2.3.2"
-    Set(organization.value %% moduleName.value % previousVersion)
-  },
-  mimaBinaryIssueFilters := Seq(
+  mimaPreviousArtifacts := Set(organization.value %% moduleName.value % "2.3.3"),
+  mimaBinaryIssueFilters := {
     // Macro internals - ignore
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.CaseClassMacros.varargTC"),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.CaseClassMacros.varargTpt"),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.CaseClassMacros.shapeless$CaseClassMacrosVersionSpecifics$_setter_$varargTC_="),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.CaseClassMacros.shapeless$CaseClassMacrosVersionSpecifics$_setter_$varargTpt_="),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.IsCons1Macros.varargTC"),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.IsCons1Macros.varargTpt"),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.IsCons1Macros.shapeless$CaseClassMacrosVersionSpecifics$_setter_$varargTC_="),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.IsCons1Macros.shapeless$CaseClassMacrosVersionSpecifics$_setter_$varargTpt_="),
-    exclude[MissingClassProblem]("shapeless.CaseClassMacros$PatchedContext$2$PatchedLookupResult"),
-    exclude[MissingTypesProblem]("shapeless.LazyMacros$"),
-    exclude[MissingClassProblem]("shapeless.LazyMacrosCompat"),
-    exclude[MissingClassProblem]("shapeless.LazyMacrosRef"),
-
-    // 2.13.x collections related - to eliminate somehow
-    exclude[DirectMissingMethodProblem]("shapeless.AdditiveCollection.indexedSeqAdditiveCollection"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.SizedOps.++"),
-    exclude[DirectMissingMethodProblem]("shapeless.Sized.apply"),
-    exclude[DirectMissingMethodProblem]("shapeless.SizedBuilder.apply"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.SizedBuilder.apply"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.syntax.SizedConv.this"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.syntax.sized.genTraversableSizedConv"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.syntax.std.traversable.traversableOps2"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.syntax.std.TraversableOps2.this"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.ops.hlist#Repeat.apply"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.ops.traversable#ToSizedHList.instance"),
-    exclude[DirectMissingMethodProblem]("shapeless.ops.hlist#ToSized.hlistToSized"),
-    exclude[IncompatibleMethTypeProblem]("shapeless.ops.traversable#FromTraversable.apply"),
-    exclude[ReversedMissingMethodProblem]("shapeless.ops.traversable#FromTraversable.apply"),
-
-    // Other
-    exclude[IncompatibleResultTypeProblem]("shapeless.syntax.HListOps.toCoproduct"),
-    exclude[InheritedNewAbstractMethodProblem]("shapeless.ops.hlist#Repeat.apply"),
-    exclude[ReversedMissingMethodProblem]("shapeless.SingletonTypeUtils.isSymbolLiteral"),
-    exclude[ReversedMissingMethodProblem]("shapeless.CaseClassMacros.numNonCaseParamLists"),
-
-    // All the following were present in 2.3.2 ...
-
-    // Filtering the methods that were added since the checked version
-    // (these only break forward compatibility, not the backward one)
-    exclude[ReversedMissingMethodProblem]("shapeless.ops.hlist#IsHCons.cons"),
-
-    // Filtering removals
-    exclude[ReversedMissingMethodProblem]("shapeless.ops.coproduct#IsCCons.cons"),
-    exclude[MissingClassProblem]("shapeless.ops.coproduct$ZipOne$"),
-    exclude[MissingClassProblem]("shapeless.ops.coproduct$ZipOne"),
-    exclude[DirectMissingMethodProblem]("shapeless.LazyMacros.dcRef"),
-    exclude[DirectMissingMethodProblem]("shapeless.LazyMacros.dcRef_="),
-
-    // Implicit reorderings
-    exclude[DirectMissingMethodProblem]("shapeless.LowPriorityUnaryTCConstraint.hnilConstUnaryTC"),
-    exclude[ReversedMissingMethodProblem]("shapeless.LowPriorityUnaryTCConstraint.hnilUnaryTC"),
-
-    // Relaxed constraints
-    exclude[IncompatibleMethTypeProblem]("shapeless.ops.traversable#ToSizedHList.apply"),
-    exclude[ReversedMissingMethodProblem]("shapeless.ops.traversable#ToSizedHList.apply")
-  )
+    val macroFilters = List("CaseClassMacros", "IsCons1Macros", "LazyMacros")
+      .map(macros => exclude[Problem](s"shapeless.$macros*"))
+
+    scalaBinaryVersion.value match {
+      case "2.11" =>
+        // Adding methods to traits in 2.11 is not binary compatible, but those traits shouldn't be subclassed.
+        exclude[ReversedMissingMethodProblem]("shapeless.LowPriorityUnaryTCConstraint.hnilUnaryTC") ::
+          exclude[ReversedMissingMethodProblem]("shapeless.SingletonTypeUtils.isSymbolLiteral") ::
+          macroFilters
+      case _ =>
+        macroFilters
+    }
+  }
 )
 
 def buildInfoSetup(crossProject: CrossProject): CrossProject = {

core/src/main/scala/shapeless/hlistconstraints.scala

@@ -16,7 +16,7 @@
 
 package shapeless
 
-import ops.hlist.Selector
+import shapeless.ops.hlist.Selector
 
 import scala.annotation.implicitNotFound
 
@@ -26,14 +26,21 @@ import scala.annotation.implicitNotFound
 trait UnaryTCConstraint[L <: HList, TC[_]] extends Serializable
 
 trait LowPriorityUnaryTCConstraint0 {
-  implicit def hlistIdUnaryTC[L <: HList] = new UnaryTCConstraint[L, Id] {}
+  implicit def hlistIdUnaryTC[L <: HList]: UnaryTCConstraint[L, Id] =
+    new UnaryTCConstraint[L, Id] {}
 }
 
 trait LowPriorityUnaryTCConstraint extends LowPriorityUnaryTCConstraint0 {
 
-  implicit def hnilUnaryTC[TC[_]] = new UnaryTCConstraint[HNil, TC] {}
+  def hnilConstUnaryTC[H]: UnaryTCConstraint[HNil, Const[H]#λ] =
+    new UnaryTCConstraint[HNil, Const[H]#λ] {}
 
-  implicit def hlistConstUnaryTC[H, T <: HList](implicit utct : UnaryTCConstraint[T, Const[H]#λ]) =
+  implicit def hnilUnaryTC[TC[_]]: UnaryTCConstraint[HNil, TC] =
+    new UnaryTCConstraint[HNil, TC] {}
+
+  implicit def hlistConstUnaryTC[H, T <: HList](
+    implicit utct: UnaryTCConstraint[T, Const[H]#λ]
+  ): UnaryTCConstraint[H :: T, Const[H]#λ] =
     new UnaryTCConstraint[H :: T, Const[H]#λ] {}
 }
 
@@ -42,11 +49,14 @@ object UnaryTCConstraint extends LowPriorityUnaryTCConstraint {
 
   type *->*[TC[_]] = {
     type λ[L <: HList] = UnaryTCConstraint[L, TC] 
-  } 
+  }
 
-  implicit def hnilConstUnaryTC[H] = new UnaryTCConstraint[HNil, Const[H]#λ] {}
+  implicit override def hnilConstUnaryTC[H]: UnaryTCConstraint[HNil, Const[H]#λ] =
+    super.hnilConstUnaryTC[H]
 
-  implicit def hlistUnaryTC[H, T <: HList, TC[_]](implicit utct : UnaryTCConstraint[T, TC]) =
+  implicit def hlistUnaryTC[H, T <: HList, TC[_]](
+    implicit utct: UnaryTCConstraint[T, TC]
+  ): UnaryTCConstraint[TC[H] :: T, TC] =
     new UnaryTCConstraint[TC[H] :: T, TC] {}
 }
 

core/src/main/scala/shapeless/ops/hlists.scala

@@ -736,7 +736,7 @@ object hlist {
     def apply(l: L): Out
   }
 
-  object ToSized {
+  object ToSized extends ToSizedVersionSpecific {
     def apply[L <: HList, M[_]](implicit toSized: ToSized[L, M]): Aux[L, M, toSized.Lub, toSized.N] = toSized
 
     type Aux[L <: HList, M[_], Lub0, N0 <: Nat] = ToSized[L, M] { type Lub = Lub0; type N = N0 }
@@ -761,23 +761,6 @@ object hlist {
         type N = Nat._1
         def apply(l : T :: HNil) = Sized[M](l.head)
       }
-
-    implicit def hlistToSized[H1, H2, T <: HList, LT, L, N0 <: Nat, M[_]]
-      (implicit
-       tts   : Aux[H2 :: T, M, LT, N0],
-       u     : Lub[H1, LT, L],
-       tvs2  : IsRegularIterable[M[LT]] { type A = LT }, // tvs2, tev, and tcbf are required for the call to map below
-       tev   : AdditiveCollection[M[LT]],
-       f     : Factory[L, M[L]],
-       tcbf  : BuildFrom[M[L], L, M[L]],
-       tcbf2 : BuildFrom[M[LT], L, M[L]],
-       tvs   : IsRegularIterable[M[L]] { type A = L }, // tvs, tcbf2, and ev are required for the call to +: below
-       ev    : AdditiveCollection[M[L]]) : Aux[H1 :: H2 :: T, M, L, Succ[N0]] =
-        new ToSized[H1 :: H2 :: T, M] {
-          type Lub = L
-          type N = Succ[N0]
-          def apply(l : H1 :: H2 :: T) = u.left(l.head) +: tts(l.tail).map(u.right)
-        }
   }
 
   /**
@@ -2095,9 +2078,7 @@ object hlist {
     *
     * @author Jeremy Smith
     */
-  trait Repeat[L <: HList, N <: Nat] extends DepFn1[L] with Serializable {
-    type Out <: HList
-  }
+  trait Repeat[L <: HList, N <: Nat] extends RepeatVersionSpecific[L]
 
   object Repeat {
 

core/src/main/scala/shapeless/sized.scala

@@ -46,7 +46,9 @@ final class Sized[+Repr, L <: Nat] private (val unsized : Repr) {
  * 
  * @author Miles Sabin
  */
-class SizedOps[A0, Repr : AdditiveCollection, L <: Nat](s : Sized[Repr, L], itl: IsRegularIterable[Repr] { type A = A0 }) { outer =>
+class SizedOps[A0, Repr : AdditiveCollection, L <: Nat](s : Sized[Repr, L], itl: IsRegularIterable[Repr] { type A = A0 })
+  extends SizedOpsVersionSpecific[A0, Repr, L] {
+
   import nat._
   import ops.nat._
   import LT._
@@ -154,18 +156,6 @@ class SizedOps[A0, Repr : AdditiveCollection, L <: Nat](s : Sized[Repr, L], itl:
     builder += elem
     wrap[Repr, Succ[L]](builder.result())
   }
-  
-  /**
-   * Append the argument collection to this collection. The resulting collection will be statically known to have
-   * ''m+n'' elements.
-   */
-  def ++[B >: A0, That, M <: Nat](that : Sized[That, M])
-    (implicit
-      sum : Sum[L, M],
-      convThat : IsRegularIterable[That] { type A = B },
-      cbf : Factory[B, That],
-      ev : AdditiveCollection[That]): Sized[That, sum.Out] =
-        wrap[That, sum.Out](cbf.fromSpecific(underlying.iterator ++ convThat(that.unsized).iterator))
 
   /**
    * Map across this collection. The resulting collection will be statically known to have the same number of elements
@@ -192,20 +182,21 @@ trait LowPrioritySized {
   implicit def sizedToRepr[Repr](s : Sized[Repr, _]) : Repr = s.unsized
 }
 
-object Sized extends LowPrioritySized {
-  implicit def sizedOps[Repr, L <: Nat](s : Sized[Repr, L])
-    (implicit itl: IsRegularIterable[Repr], ev: AdditiveCollection[Repr]): SizedOps[itl.A, Repr, L] =
-      new SizedOps[itl.A, Repr, L](s, itl)
+object Sized extends SizedVersionSpecific with LowPrioritySized {
+
+  implicit def sizedOps[Repr, L <: Nat](s: Sized[Repr, L])(
+    implicit itl: IsRegularIterable[Repr],
+    ev: AdditiveCollection[Repr]
+  ): SizedOps[itl.A, Repr, L] =
+    new SizedOps[itl.A, Repr, L](s, itl)
 
   def apply[CC[_]] = new SizedBuilder[CC]
 
-  def apply[CC[_]]()
-    (implicit dis: DefaultToIndexedSeq[CC], cbf : Factory[Nothing, CC[Nothing]], ev : AdditiveCollection[CC[Nothing]]) =
-      new Sized[CC[Nothing], _0](cbf.newBuilder.result())
-  
-  def wrap[Repr, L <: Nat](r : Repr)(implicit ev : AdditiveCollection[Repr]) = new Sized[Repr, L](r)
+  def wrap[Repr, L <: Nat](r : Repr)(implicit ev: AdditiveCollection[Repr]): Sized[Repr, L] =
+    new Sized[Repr, L](r)
 
-  def unapplySeq[Repr, L <: Nat](x : Sized[Repr, L]) = Some(x.unsized)
+  def unapplySeq[Repr, L <: Nat](x: Sized[Repr, L]): Some[Repr] =
+    Some(x.unsized)
 }
 
 /**
@@ -217,7 +208,7 @@ object Sized extends LowPrioritySized {
  */
 trait AdditiveCollection[Repr] extends Serializable
 
-object AdditiveCollection {
+object AdditiveCollection extends AdditiveCollectionVersionSpecific {
   import scala.collection.immutable.Queue
   import scala.collection.LinearSeq
 

core/src/main/scala/shapeless/syntax/hlists.scala

@@ -609,7 +609,7 @@ final class HListOps[L <: HList](l : L) extends Serializable {
     *
     * Note that the `M` container must extend `Traversable`, which means that `Array` cannot be used.
     */
-  def toCoproduct[M[_] <: Iterable[_]](implicit toCoproductTraversable: ToCoproductTraversable[L, M]): toCoproductTraversable.Out = toCoproductTraversable(l)
+  def toCoproduct[M[_] <: TraversableOrIterable[_]](implicit toCoproductTraversable: ToCoproductTraversable[L, M]): toCoproductTraversable.Out = toCoproductTraversable(l)
 
   /**
    * Converts this `HList` to a - sized - `M` of elements typed as the least upper bound of the types of the elements

core/src/main/scala/shapeless/syntax/std/traversables.scala

@@ -28,17 +28,17 @@ package std
  * @author Rob Norris
  */
 object traversable {
-  implicit def traversableOps[T](t : T)(implicit ev: T => Iterable[_]) = new TraversableOps(t)
-  implicit def traversableOps2[CC[T] <: Iterable[T], A](as: CC[A]) = new TraversableOps2(as)
+  implicit def traversableOps[T](t: T)(implicit ev: T => GenTraversableOrIterable[_]): TraversableOps[T] = new TraversableOps(t)
+  implicit def traversableOps2[CC[T] <: GenTraversableOrIterable[T], A](as: CC[A]): TraversableOps2[CC, A] = new TraversableOps2(as)
 }
 
-final class TraversableOps[T](t : T)(implicit ev: T => Iterable[_]) {
+final class TraversableOps[T](t : T)(implicit ev: T => GenTraversableOrIterable[_]) {
   import ops.traversable._
 
-  def toHList[L <: HList](implicit fl : FromTraversable[L]) : Option[L] = fl(t)
+  def toHList[L <: HList](implicit fl: FromTraversable[L]): Option[L] = fl(t)
 }
 
-final class TraversableOps2[CC[T] <: Iterable[T], A](as: CC[A]) {
+final class TraversableOps2[CC[T] <: GenTraversableOrIterable[T], A](as: CC[A]) {
   import ops.traversable._
 
   def toSizedHList(n: Nat)(implicit ts: ToSizedHList[CC, A, n.N]): ts.Out = ts(as)