Fix support of named tuples for different combination of tuple kinds when defining names and value types

Author: plokhotnyuk

build.sbt

@@ -215,7 +215,7 @@ lazy val `jsoniter-scala-next-tests` = crossProject(JVMPlatform, JSPlatform, Nat
   .settings(commonSettings)
   .settings(noPublishSettings)
   .settings(
-    crossScalaVersions := Seq("3.7.3-RC1", "2.13.16"),
+    crossScalaVersions := Seq("3.7.3-RC1"),
     libraryDependencies ++= Seq(
       "org.scalatestplus" %%% "scalacheck-1-18" % "3.2.19.0" % Test,
       "org.scalatest" %%% "scalatest" % "3.2.19" % Test

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

@@ -980,7 +980,7 @@ object JsonCodecMaker {
         def genNew(argss: List[List[Term]]): Term
       }
 
-      case class NamedTupleInfo(tpe: TypeRepr, tupleType: Type[?],
+      case class NamedTupleInfo(tpe: TypeRepr, tupleType: Type[?], isGeneric: Boolean,
                                 override val paramLists: List[List[FieldInfo]]) extends TypeInfo(tpe, paramLists) {
         def genNew(argss: List[List[Term]]): Term =
           // Borrowed from an amazing work of Aleksander Rainko: https://github.com/arainko/ducktape/blob/8d779f0303c23fd45815d3574467ffc321a8db2b/ducktape/src/main/scala/io/github/arainko/ducktape/internal/ProductConstructor.scala#L22
@@ -991,16 +991,20 @@ object JsonCodecMaker {
 
       def getNamedTupleInfo(tpe: TypeRepr): NamedTupleInfo = namedTupleInfos.getOrElseUpdate(tpe, {
         tpe match {
-          case AppliedType(ntTpe, List(nTpe@AppliedType(_, nameConstants), tTpe)) if ntTpe.dealias.typeSymbol.fullName == "scala.NamedTuple$.NamedTuple" =>
-            val fields =
-              if (isGenericTuple(tTpe)) namedGenericTupleNames(nTpe).zip(genericTupleTypeArgs(tTpe))
-              else nameConstants.collect { case ConstantType(StringConstant(x)) => x}.zip(typeArgs(tTpe))
+          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)
             val noSymbol = Symbol.noSymbol
             var i = - 1
-            NamedTupleInfo(tpe, tTpe.asType, List(fields.map { case (name, fTpe) =>
+            NamedTupleInfo(tpe, tTpe.asType, isGeneric, List(names.zip(types).map { case (name, fTpe) =>
               i += 1
-              val mappedName = cfg.fieldNameMapper (name).getOrElse (name)
-              FieldInfo (noSymbol, mappedName, noSymbol, None, fTpe, false, false, i)
+              val mappedName = cfg.fieldNameMapper(name).getOrElse(name)
+              FieldInfo(noSymbol, mappedName, noSymbol, None, fTpe, false, false, i)
             }))
           case _ => fail(s"Unexpected named type: ${tpe.show}")
         }
@@ -2726,9 +2730,7 @@ object JsonCodecMaker {
                                                  optDiscriminator: Option[WriteDiscriminator],
                                                  out: Expr[JsonWriter])(using Quotes): Expr[Unit] =
         val tpe = types.head
-        var i = -1
         val writeFields = typeInfo.fields.map { fieldInfo =>
-          i += 1
           val fDefault =
             if (cfg.transientDefault) fieldInfo.defaultValue
             else None
@@ -2737,9 +2739,11 @@ object JsonCodecMaker {
             case '[ft] =>
               val getter = typeInfo match {
                 case namedTupleInfo: NamedTupleInfo =>
-                  if (typeInfo.fields.size > 22) '{ $x.asInstanceOf[Tuple].productElement(${Expr(i)}).asInstanceOf[ft] }.asTerm
-                  else namedTupleInfo.tupleType match {
-                    case '[tt] => Select.unique('{ $x.asInstanceOf[tt] }.asTerm, s"_${i + 1}")
+                  val idx = fieldInfo.nonTransientFieldIndex
+                  if (namedTupleInfo.isGeneric) {
+                    '{ $x.asInstanceOf[Tuple].productElement(${Expr(idx)}).asInstanceOf[ft] }.asTerm
+                  } else namedTupleInfo.tupleType match {
+                    case '[tt] => Select.unique('{ $x.asInstanceOf[tt] }.asTerm, s"_${idx + 1}")
                   }
                 case _ => Select(x.asTerm, fieldInfo.getterOrField)
               }

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

@@ -8,10 +8,24 @@ class JsonCodecMakerNamedTupleSpec extends VerifyingSpec {
     "serialize and deserialize Scala 3 named tuples" in {
       verifySerDeser(make[(i: Int, s: String)], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
     }
+    "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"}""")
+    }
+    "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"}""")
+    }
     "serialize and deserialize generic Scala 3 named tuples" in {
-      type GenericNamedTuple[A, B] = (i: A, s: B)
+      type GenericNamedTuple[A, B] = (a: A, b: B)
+
+      verifySerDeser(make[GenericNamedTuple[Option[Int], List[String]]], (a = Some(1), b = List("VVV")),
+        """{"a":1,"b":["VVV"]}""")
+    }
+    "serialize and deserialize higher-kind Scala 3 named tuples" in {
+      type HKNamedTuple[F[_], G[_]] = (i: F[Int], s: G[String])
 
-      verifySerDeser(make[GenericNamedTuple[Option[Int], List[String]]], (i = Some(1), s = List("VVV")),
+      verifySerDeser(make[HKNamedTuple[Option, List]], (i = Some(1), s = List("VVV")),
         """{"i":1,"s":["VVV"]}""")
     }
     "serialize and deserialize nested Scala 3 named tuples" in {