Merge branch 'joroKr21-existentials'

2 files changed, 35 insertions, 8 deletions

diff --git a/core/shared/src/main/scala/magnolia.scala b/core/shared/src/main/scala/magnolia.scala
index 6528db0..a748561 100644
--- a/core/shared/src/main/scala/magnolia.scala
+++ b/core/shared/src/main/scala/magnolia.scala
@@ -65,6 +65,7 @@ object Magnolia {
     *  */
   def gen[T: c.WeakTypeTag](c: whitebox.Context): c.Tree = {
     import c.universe._
+    import internal._
 
     val magnoliaPkg = q"_root_.magnolia"
     val scalaPkg = q"_root_.scala"
@@ -250,9 +251,7 @@ object Magnolia {
         val caseParamsReversed = caseClassParameters.foldLeft[List[CaseParam]](Nil) {
           (acc, param) =>
             val paramName = param.name.decodedName.toString
-            val paramTypeSubstituted = param.returnType.substituteTypes(
-              genericType.etaExpand.typeParams,
-              genericType.typeArgs)
+            val paramTypeSubstituted = param.typeSignatureIn(genericType).resultType
 
             val (repeated, paramType) = paramTypeSubstituted match {
               case TypeRef(_, `repeatedParamClass`, typeArgs) =>
@@ -345,10 +344,13 @@ object Magnolia {
       } else if (isSealedTrait) {
         val genericSubtypes = classType.get.knownDirectSubclasses.to[List]
         val subtypes = genericSubtypes.map { sub =>
-          val typeArgs = sub.asType.typeSignature.baseType(genericType.typeSymbol).typeArgs
-          val mapping = typeArgs.zip(genericType.typeArgs).toMap
-          val newTypeParams = sub.asType.toType.typeArgs.map(mapping(_))
-          appliedType(sub.asType.toType.typeConstructor, newTypeParams)
+          val subType = sub.asType.toType // FIXME: Broken for path dependent types
+          val typeParams = sub.asType.typeParams
+          val typeArgs = thisType(sub).baseType(genericType.typeSymbol).typeArgs
+          val mapping = (typeArgs.map(_.typeSymbol), genericType.typeArgs).zipped.toMap
+          val newTypeArgs = typeParams.map(mapping.withDefault(_.asType.toType))
+          val applied = appliedType(subType.typeConstructor, newTypeArgs)
+          existentialAbstraction(typeParams, applied)
         }
 
         if (subtypes.isEmpty) {
diff --git a/tests/src/main/scala/tests.scala b/tests/src/main/scala/tests.scala
index 96a2c2b..df4dfd6 100644
--- a/tests/src/main/scala/tests.scala
+++ b/tests/src/main/scala/tests.scala
@@ -47,10 +47,19 @@ object Test {
   def apply(a: String, b: String): Test = Test(Param(a, b))
 }
 
+sealed trait Politician[+S]
+case class Accountable[+S](slogan: S) extends Politician[S]
+case class Corrupt[+S, +L <: Seq[Company]](slogan: S, lobby: L) extends Politician[S]
+
+sealed trait Box[+A]
+case class SimpleBox[+A](value: A) extends Box[A]
+case class LabelledBox[+A, L <: String](value: A, var label: L) extends Box[A]
+
 case class Account(id: String, emails: String*)
 
 case class Portfolio(companies: Company*)
 
+
 object Tests extends TestApp {
 
   def tests() = for (i <- 1 to 1) {
@@ -206,6 +215,22 @@ object Tests extends TestApp {
       Show.gen[Length].show(new Length(100))
     }.assert(_ == "100")
 
+
+    // Corrupt being covariant in L <: Seq[Company] enables the derivation for Corrupt[String, _]
+    test("show a Politician with covariant lobby") {
+      Show.gen[Politician[String]].show(Corrupt("wall", Seq(Company("Alice Inc"))))
+    }.assert(_ == "Corrupt(slogan=wall,lobby=[Company(name=Alice Inc)])")
+
+    // LabelledBox being invariant in L <: String prohibits the derivation for LabelledBox[Int, _]
+    test("can't show a Box with invariant label") {
+      scalac"Show.gen[Box[Int]]"
+    }.assert { _ == TypecheckError(
+      txt"""magnolia: could not find typeclass for type L
+        |    in parameter 'label' of product type magnolia.tests.LabelledBox[Int, _ <: String]
+        |    in coproduct type magnolia.tests.Box[Int]
+        |""")
+    }
+
     test("show an Account") {
       Show.gen[Account].show(Account("john_doe", "john.doe@yahoo.com", "john.doe@gmail.com"))
     }.assert(_ == "Account(id=john_doe,emails=[john.doe@yahoo.com,john.doe@gmail.com])")
@@ -226,6 +251,6 @@ object Tests extends TestApp {
       implicit val stringTypeName: TypeName[String] = new TypeName[String] { def name = "" }
       TypeName.gen[Fruit].name
     }.assert(_ == "magnolia.tests.Fruit")
-
+    ()
   }
 }