Add support of type references + tests for recursive tuple types

Author: plokhotnyuk

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

@@ -931,6 +931,16 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
     case trTpe: TypeRef if trTpe.isOpaqueAlias => opaqueDealias(trTpe.translucentSuperType.dealias)
     case _ => tpe
 
+  private def isTypeRef(tpe: TypeRepr): Boolean = tpe match
+    case trTpe: TypeRef =>
+      val typeSymbol = trTpe.typeSymbol
+      typeSymbol.isTypeDef && typeSymbol.isAliasType
+    case _ => false
+
+  private def typeRefDealias(tpe: TypeRepr): TypeRepr = tpe match
+    case trTpe: TypeRef => trTpe.translucentSuperType.dealias
+    case _ => tpe
+
   private def isSealedClass(tpe: TypeRepr): Boolean = tpe.typeSymbol.flags.is(Flags.Sealed)
 
   private def hasSealedParent(tpe: TypeRepr): Boolean =
@@ -1395,6 +1405,9 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
     } else if (isOpaque(tpe)) {
       val sTpe = opaqueDealias(tpe)
       sTpe.asType match { case '[s] => '{ ${genReadKey[s](sTpe :: types.tail, in)}.asInstanceOf[T] } }
+    } else if (isTypeRef(tpe)) {
+      val sTpe = typeRefDealias(tpe)
+      sTpe.asType match { case '[s] => '{ ${genReadKey[s](sTpe :: types.tail, in)}.asInstanceOf[T] } }
     } else cannotFindKeyCodecError(tpe)
   }.asInstanceOf[Expr[T]]
 
@@ -1618,6 +1631,9 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
     } else if (isOpaque(tpe)) {
       val sTpe = opaqueDealias(tpe)
       sTpe.asType match { case '[s] => genWriteKey('{ $x.asInstanceOf[s] }, sTpe :: types.tail, out) }
+    } else if (isTypeRef(tpe)) {
+      val sTpe = typeRefDealias(tpe)
+      sTpe.asType match { case '[s] => genWriteKey('{ $x.asInstanceOf[s] }, sTpe :: types.tail, out) }
     } else cannotFindKeyCodecError(tpe)
 
   private def genWriteConstantKey(name: String, out: Expr[JsonWriter])(using Quotes): Expr[Unit] =
@@ -1928,6 +1944,9 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
     else if (isOpaque(tpe) && !isNamedTuple(tpe)) {
       val sTpe = opaqueDealias(tpe)
       sTpe.asType match { case '[st] => '{ ${genNullValue[st](sTpe :: types.tail)}.asInstanceOf[T] } }
+    } else if (isTypeRef(tpe)) {
+      val sTpe = typeRefDealias(tpe)
+      sTpe.asType match { case '[st] => '{ ${genNullValue[st](sTpe :: types.tail)}.asInstanceOf[T] } }
     } else if (isConstType(tpe)) tpe match { case ConstantType(c) => Literal(c).asExpr }
     else '{ null.asInstanceOf[T] }
   }.asInstanceOf[Expr[T]]
@@ -2370,7 +2389,7 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
           val types1 = tpe1 :: types
           val newArrayOnChange = tpe1 match
             case _: AppliedType => true
-            case _ => isValueClass(tpe1) || isOpaque(tpe1)
+            case _ => isValueClass(tpe1) || isOpaque(tpe1) || isTypeRef(tpe1)
           tpe1.asType match
             case '[t1] =>
               def growArray(x: Expr[Array[t1]], i: Expr[Int], l: Expr[Int])(using Quotes): Expr[Array[t1]] =
@@ -2782,6 +2801,12 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
           case '[s] =>
             val newDefault = '{ $default.asInstanceOf[s] }.asInstanceOf[Expr[s]]
             '{ ${genReadVal[s](sTpe :: types.tail, newDefault, isStringified, useDiscriminator, in)}.asInstanceOf[T] }
+      } else if (isTypeRef(tpe)) {
+        val sTpe = typeRefDealias(tpe)
+        sTpe.asType match
+          case '[s] =>
+            val newDefault = '{ $default.asInstanceOf[s] }.asInstanceOf[Expr[s]]
+            '{ ${genReadVal[s](sTpe :: types.tail, newDefault, isStringified, useDiscriminator, in)}.asInstanceOf[T] }
       } else if (isConstType(tpe)) genReadConstType(tpe, isStringified, in)
       else cannotFindValueCodecError(tpe)
     }
@@ -3305,6 +3330,11 @@ private class JsonCodecMakerInstance(cfg: CodecMakerConfig)(using Quotes) {
         sTpe.asType match
           case '[s] =>
             genWriteVal[s]('{ $m.asInstanceOf[s] }, sTpe :: types.tail, isStringified, optWriteDiscriminator, out)
+      } else if (isTypeRef(tpe)) {
+        val sTpe = typeRefDealias(tpe)
+        sTpe.asType match
+          case '[s] =>
+            genWriteVal[s]('{ $m.asInstanceOf[s] }, sTpe :: types.tail, isStringified, optWriteDiscriminator, out)
       } else cannotFindValueCodecError(tpe)
     }
   }.asInstanceOf[Expr[Unit]]

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

@@ -76,10 +76,18 @@ class JsonCodecMakerNamedTupleSpec extends VerifyingSpec {
       verifySerDeser(make[List[(i: Int, s: String)]], List((i = 1, s = "VVV"), (i = 2, s = "WWW")),
         """[{"i":1,"s":"VVV"},{"i":2,"s":"WWW"}]""")
     }
-    "serialize and deserialize generic and named tuples" in {
+    "serialize and deserialize complex generic and named tuples" in {
       verifySerDeser(make[Tuple.++[(Byte, Short), (Int, Long)]], (1: Byte, 2: Short, 3, 4L), "[1,2,3,4]")
       verifySerDeser(make[Tuple.Reverse[(String, Int)]], (1, "VVV"), """[1,"VVV"]""")
       verifySerDeser(make[NamedTuple.DropNames[(i: Int, s: String)]], (1, "VVV"), """[1,"VVV"]""")
     }
+    "serialize and deserialize recursive regular and named tuples" in {
+      type RecursiveTuple = (Int, Option[RecursiveTuple])
+      type RecursiveNamedTuple = (value: Int, next: Option[RecursiveNamedTuple])
+      verifySerDeser(make[RecursiveTuple](CodecMakerConfig.withAllowRecursiveTypes(true)),
+        (1, Some((2, None))), "[1,[2,null]]")
+      verifySerDeser(make[RecursiveNamedTuple](CodecMakerConfig.withAllowRecursiveTypes(true)),
+        (value = 1, next = Some((2, None))), """{"value":1,"next":{"value":2}}""")
+    }
   }
 }