Fix support of generic and named tuples for complex cases

Author: plokhotnyuk

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

@@ -778,18 +778,13 @@ object JsonCodecMaker {
         case _ => false
       }
 
-      def genericTupleTypeArgs(tpe: TypeRepr): List[TypeRepr] = tpe match {
-        case AppliedType(_, List(typeArg, tail)) => typeArg.dealias :: genericTupleTypeArgs(tail)
-        case _ => Nil
-      }
-
       def isNamedTuple(tpe: TypeRepr): Boolean = tpe match {
         case AppliedType(ntTpe, _) if ntTpe.dealias.typeSymbol.fullName == "scala.NamedTuple$.NamedTuple" => true
         case _ => false
       }
 
-      def namedGenericTupleNames(tpe: TypeRepr): List[String] = tpe match {
-        case AppliedType(_, List(ConstantType(StringConstant(name)), tail)) => name :: namedGenericTupleNames(tail)
+      def tupleTypeArgs(t: Type[?]): List[TypeRepr] = t match {
+        case '[head *: tail] => TypeRepr.of[head] :: tupleTypeArgs(Type.of[tail])
         case _ => Nil
       }
 
@@ -991,17 +986,21 @@ object JsonCodecMaker {
 
       def getNamedTupleInfo(tpe: TypeRepr): NamedTupleInfo = namedTupleInfos.getOrElseUpdate(tpe, {
         tpe match {
-          case AppliedType(_, List(nTpe @ AppliedType(_, nameConstants), tTpe)) =>
-            val names =
-              if (isGenericTuple(nTpe)) namedGenericTupleNames(nTpe)
-              else nameConstants.collect { case ConstantType(StringConstant(x)) => x }
-            val isGeneric = isGenericTuple(tTpe)
-            val types =
-              if (isGeneric) genericTupleTypeArgs(tTpe)
-              else typeArgs(tTpe)
+          case AppliedType(_, List(nTpe, tTpe)) =>
+            // Borrowed from an amazing work of Aleksander Rainko: https://github.com/arainko/ducktape/blob/8d779f0303c23fd45815d3574467ffc321a8db2b/ducktape/src/main/scala/io/github/arainko/ducktape/internal/Structure.scala#L188-L199
+            val names = tupleTypeArgs(nTpe.asType).map { case ConstantType(StringConstant(n)) => n }
+            val typeArgs = tupleTypeArgs(tTpe.asType)
+            val size = typeArgs.size
+            val tupleTpe =
+              if (size <= 22) defn.TupleClass(size).typeRef.appliedTo(typeArgs)
+              else typeArgs.foldRight(TypeRepr.of[EmptyTuple]) {
+                val tupleCons = TypeRepr.of[*:]
+                (curr, acc) => tupleCons.appliedTo(curr :: acc :: Nil)
+              }
+            val isGeneric = isGenericTuple(tupleTpe)
             val noSymbol = Symbol.noSymbol
             var i = - 1
-            NamedTupleInfo(tpe, tTpe.asType, isGeneric, List(names.zip(types).map { case (name, fTpe) =>
+            NamedTupleInfo(tpe, tupleTpe.asType, isGeneric, List(names.zip(typeArgs).map { case (name, fTpe) =>
               i += 1
               val mappedName = cfg.fieldNameMapper(name).getOrElse(name)
               FieldInfo(noSymbol, mappedName, noSymbol, None, fTpe, false, false, i)
@@ -2677,7 +2676,7 @@ object JsonCodecMaker {
         } else if (isTuple(tpe)) withDecoderFor(methodKey, default, in) { (in, default) =>
           val isGeneric = isGenericTuple(tpe)
           val indexedTypes =
-            if (isGeneric) genericTupleTypeArgs(tpe)
+            if (isGeneric) tupleTypeArgs(tpe.asType)
             else typeArgs(tpe)
           val valDefs = indexedTypes.map {
             var i = 0
@@ -3161,7 +3160,7 @@ object JsonCodecMaker {
         } else if (isTuple(tpe)) withEncoderFor(methodKey, m, out) { (out, x) =>
           val isGeneric = isGenericTuple(tpe)
           val indexedTypes =
-            if (isGeneric) genericTupleTypeArgs(tpe)
+            if (isGeneric) tupleTypeArgs(tpe.asType)
             else typeArgs(tpe)
           val writeFields = indexedTypes.map {
             var i = 0

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

@@ -63,9 +63,13 @@ class JsonCodecMakerNewTypeSpec extends VerifyingSpec {
         """[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,"24"]""")
     }
     "serialize and deserialize Scala 3 generic tuples" in {
-      verifySerDeser(make[(Byte *: Short *: Int *: Long *: EmptyTuple)],
-        (1: Byte) *: (2: Short) *: 3 *: 4L *: EmptyTuple,
-        """[1,2,3,4]""")
+      verifySerDeser(make[Byte *: Short *: Int *: Long *: EmptyTuple],
+        (1: Byte) *: (2: Short) *: 3 *: 4L *: EmptyTuple, """[1,2,3,4]""")
+      verifySerDeser(make[Byte *: Short *: Tuple2[Int, Long]],
+        (1: Byte) *: (2: Short) *: (3, 4L), """[1,2,3,4]""")
+      verifySerDeser(make[Tuple.Concat[(Byte, Short), (Int, Long)]], (1: Byte, 2: Short, 3, 4L), """[1,2,3,4]""")
+      verifySerDeser(make[Tuple.Drop[(Long, Int, String), 1]], (1, "VVV"), """[1,"VVV"]""")
+      verifySerDeser(make[Tuple.Take[(Int, String, Long), 2]], (1, "VVV"), """[1,"VVV"]""")
     }
     "serialize and deserialize Scala 3 immutable array" in {
       val json = """{"aa":[[1,2],[3,4]],"a":[1,2,3,4]}"""

jsoniter-scala-next-tests/shared/src/test/scala-3/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMakerNamedTupleSpec.scala

@@ -7,14 +7,34 @@ class JsonCodecMakerNamedTupleSpec extends VerifyingSpec {
   "JsonCodecMaker.make generate codecs which" should {
     "serialize and deserialize Scala 3 named tuples" in {
       verifySerDeser(make[(i: Int, s: String)], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Reverse[(i: Int, s: String)]], (s = "VVV", i = 1), """{"s":"VVV","i":1}""")
+      verifySerDeser(make[NamedTuple.Concat[(i: Int), (s: String)]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Tail[(l: Long, i: Int, s: String)]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Init[(i: Int, s: String, l: Long)]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Drop[(l: Long, i: Int, s: String), 1]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Take[(i: Int, s: String, l: Long), 2]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.Split[(i: Int, s: String, l: Long), 2]], ((i = 1, s = "VVV"), (l = 2L)),
+        """[{"i":1,"s":"VVV"},{"l":2}]""")
+      verifySerDeser(make[NamedTuple.Zip[(i: Int, s: String), (i: Long, s: String)]], (i = (1, 2L), s = ("VVV", "WWW")),
+        """{"i":[1,2],"s":["VVV","WWW"]}""")
+    }
+    "serialize and deserialize Scala 3 tuples derived from named tuples" in {
+      verifySerDeser(make[NamedTuple.DropNames[(i: Int, s: String)]], (1, "VVV"), """[1,"VVV"]""")
+    }
+    "serialize and deserialize Scala 3 tuples derived from tuples" in {
+      verifySerDeser(make[Tuple.Reverse[(Long, Int, Short, Byte)]], (1: Byte, 2: Short, 3, 4L), """[1,2,3,4]""")
     }
     "serialize and deserialize Scala 3 named tuples with generic tuple for names" in {
       verifySerDeser(make[NamedTuple.NamedTuple["i" *: "s" *: EmptyTuple, (Int, String)]], 
-      (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+        (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.NamedTuple["i" *: ("s", "l"), (Int, String, Long)]],
+        (i = 1, s = "VVV", l = 2L), """{"i":1,"s":"VVV","l":2}""")
     }
     "serialize and deserialize Scala 3 named tuples with generic tuple for value types" in {
-      verifySerDeser(make[NamedTuple.NamedTuple[("i", "s"), Int *: String *: EmptyTuple]], 
-      (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.NamedTuple[("i", "s"), Int *: String *: EmptyTuple]],
+        (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
+      verifySerDeser(make[NamedTuple.NamedTuple[("i", "s", "l"), Int *: Tuple2[String, Long]]],
+        (i = 1, s = "VVV", l = 2L), """{"i":1,"s":"VVV","l":2}""")
     }
     "serialize and deserialize generic Scala 3 named tuples" in {
       type GenericNamedTuple[A, B] = (a: A, b: B)