Add missing dealiasing when deriving codecs for generic and named tuples

Author: plokhotnyuk

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

@@ -774,20 +774,20 @@ object JsonCodecMaker {
       def isTuple(tpe: TypeRepr): Boolean = tpe <:< TypeRepr.of[Tuple]
 
       def isGenericTuple(tpe: TypeRepr): Boolean = tpe match {
-        case AppliedType(tTpe, _) if tTpe =:= TypeRepr.of[*:] => true
+        case AppliedType(gtTpe, _) if gtTpe.dealias =:= TypeRepr.of[*:] => true
         case _ => tpe =:= TypeRepr.of[EmptyTuple]
       }
 
+      def tupleTypeArgs(t: Type[?]): List[TypeRepr] = t match {
+        case '[head *: tail] => TypeRepr.of[head].dealias :: tupleTypeArgs(Type.of[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 tupleTypeArgs(t: Type[?]): List[TypeRepr] = t match {
-        case '[head *: tail] => TypeRepr.of[head] :: tupleTypeArgs(Type.of[tail])
-        case _ => Nil
-      }
-
       def valueClassValueSymbol(tpe: TypeRepr): Symbol = tpe.typeSymbol.fieldMembers.head
 
       def valueClassValueType(tpe: TypeRepr): TypeRepr = tpe.memberType(valueClassValueSymbol(tpe)).dealias
@@ -1000,14 +1000,14 @@ object JsonCodecMaker {
         tpe match {
           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 names = tupleTypeArgs(nTpe.dealias.asType).map { case ConstantType(StringConstant(n)) => n }
+            val typeArgs = tupleTypeArgs(tTpe.dealias.asType)
             val size = typeArgs.size
             val tupleTpe =
               if (size > 0 && 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)
+                (curr, acc) => tupleCons.appliedTo(List(curr, acc))
               }
             val noSymbol = Symbol.noSymbol
             var i = - 1

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

@@ -63,9 +63,15 @@ 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 generic tuples" in {
+      type B = Byte
+      type I = Int
+      type L = Long
+      type S = Short
+
       verifySerDeser(make[EmptyTuple], EmptyTuple, "[]")
       verifySerDeser(make[Tuple.Drop[(Long, Int, String), 3]], EmptyTuple, "[]")
       verifySerDeser(make[Byte *: Short *: Int *: Long *: EmptyTuple], (1: Byte, 2: Short, 3, 4L), "[1,2,3,4]")
+      verifySerDeser(make[B *: S *: I *: L *: EmptyTuple], (1: Byte, 2: Short, 3, 4L), "[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.Append[(Byte, Short), Int]], (1: Byte, 2: Short, 3), "[1,2,3]")

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

@@ -23,6 +23,13 @@ class JsonCodecMakerNamedTupleSpec extends VerifyingSpec {
     "serialize and deserialize complex named tuples" in {
       case class Record(i: Int, s: String)
 
+      type *:: = *:
+      type Names = "i" *:: "s" *:: EmptyTuple
+      type I = Int
+      type S = String
+      type Values = I *:: S *:: EmptyTuple
+
+      verifySerDeser(make[NamedTuple.NamedTuple[Names, Values]], (i = 1, s = "VVV"), """{"i":1,"s":"VVV"}""")
       verifySerDeser(make[NamedTuple.From[Record]], (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"}""")