Fix codec derivation using Scala 2 for generic ADT with free type parameters for cases

Author: plokhotnyuk

jsoniter-scala-macros/shared/src/main/scala-2/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMaker.scala

@@ -978,20 +978,30 @@ object JsonCodecMaker {
         def collectRecursively(tpe: Type): Unit = {
           val tpeTypeArgs = typeArgs(tpe)
           val tpeClass = tpe.typeSymbol.asClass
-          var typeParamsAndArgs = Map.empty[String, Type]
+          var typeParamsAndArgs = Map.empty[Symbol, Type]
           if (tpeTypeArgs ne Nil) tpeClass.typeParams.zip(tpeTypeArgs).foreach { case (typeParam, typeArg) =>
-            typeParamsAndArgs = typeParamsAndArgs.updated(typeParam.toString, typeArg)
+            typeParamsAndArgs = typeParamsAndArgs.updated(typeParam, typeArg)
           }
           val subClasses = tpeClass.knownDirectSubclasses.toArray
           scala.util.Sorting.stableSort(subClasses)
           subClasses.foreach { s =>
             val classSymbol = s.asClass
             var subTpe = classSymbol.toType
-            if (tpeTypeArgs ne Nil) {
-              val typeParams = classSymbol.typeParams
-              subTpe = subTpe.substituteTypes(typeParams, typeParams.map(tp => typeParamsAndArgs.getOrElse(tp.toString, fail {
-                s"Cannot resolve generic type(s) for '$subTpe'. Please provide a custom implicitly accessible codec for it."
-              })))
+            val typeParams = classSymbol.typeParams
+            if (typeParams.nonEmpty) {
+              val subTpeBaseTypeArgs = typeArgs(subTpe.baseType(tpeClass))
+              var subTpeParamsToArgs = Map.empty[Symbol, Type]
+              subTpeBaseTypeArgs.zip(tpeTypeArgs).foreach { case (childBaseTypeArg, typeArg) =>
+                childBaseTypeArg match {
+                  case TypeRef(_, typeParam, Nil) => subTpeParamsToArgs = subTpeParamsToArgs.updated(typeParam, typeArg)
+                  case _ =>
+                }
+              }
+              subTpe = subTpe.substituteTypes(typeParams, typeParams.map { typeParam =>
+                subTpeParamsToArgs.getOrElse(typeParam, typeParamsAndArgs.getOrElse(typeParam, fail {
+                  s"Cannot resolve generic type(s) for '$subTpe'. Please provide a custom implicitly accessible codec for it."
+                }))
+              })
             }
             if (isSealedClass(subTpe)) collectRecursively(subTpe)
             else if (isValueClass(subTpe)) {

jsoniter-scala-macros/shared/src/test/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMakerSpec.scala

@@ -6,6 +6,7 @@ import java.util.{Objects, UUID}
 import com.github.plokhotnyuk.jsoniter_scala.core.{JsonValueCodec, _}
 import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker._
 import org.scalatest.exceptions.TestFailedException
+
 import java.util.concurrent.ThreadLocalRandom
 import scala.annotation.switch
 import scala.util.control.NonFatal
@@ -3112,6 +3113,16 @@ class JsonCodecMakerSpec extends VerifyingSpec {
       verifySerDeser(codecOfFooForOption, Bar[Option](_root_.scala.Some(1)), """{"type":"Bar","a":1}""")
       verifySerDeser(codecOfFooForOption, Baz[Option](_root_.scala.Some("VVV")), """{"type":"Baz","a":"VVV"}""")
     }
+    "serialize and deserialize generic ADT with free type parameters for cases" in {
+      sealed trait GADT[A] extends Product with Serializable
+
+      case class FixedType(value: Int) extends GADT[Int]
+
+      case class VarType[B](value: B)  extends GADT[B]
+
+      verifySerDeser(make[List[GADT[Int]]], List(FixedType(100), VarType(200)),
+        """[{"type":"FixedType","value":100},{"type":"VarType","value":200}]""")
+    }
     "serialize and deserialize recursive higher-kinded types" in {
       case class HigherKindedType[F[_]](f: F[Int], fs: F[HigherKindedType[F]])