Add missing support of mutable.CollisionProofHashMap

Author: plokhotnyuk

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

@@ -694,6 +694,9 @@ object JsonCodecMaker {
       def isMutableArraySeq(tpe: Type): Boolean =
         isScala213 && tpe.typeSymbol.fullName == "scala.collection.mutable.ArraySeq"
 
+      def isCollisionProofHashMap(tpe: Type): Boolean =
+        isScala213 && tpe.typeSymbol.fullName == "scala.collection.mutable.CollisionProofHashMap"
+
       def inferImplicitValue(typeTree: Tree): Tree = c.inferImplicitValue(c.typecheck(typeTree, c.TYPEmode).tpe)
 
       def checkRecursionInTypes(types: List[Type]): Unit =
@@ -1612,7 +1615,7 @@ object JsonCodecMaker {
             genReadMapAsArray(newBuilder,
               q"x = x.updated($readKey, { if (in.isNextToken(',')) $readVal else in.commaError() })")
           } else genReadMap(newBuilder, q"x = x.updated(in.readKeyAsLong(), $readVal)")
-        } else if (tpe <:< typeOf[mutable.Map[_, _]]) withDecoderFor(methodKey, default) {
+        } else if (tpe <:< typeOf[mutable.Map[_, _]] || isCollisionProofHashMap(tpe)) withDecoderFor(methodKey, default) {
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)
           val newBuilder = q"{ val x = if (default.isEmpty) default else ${scalaCollectionCompanion(tpe)}.empty[$tpe1, $tpe2] }"
@@ -2045,7 +2048,7 @@ object JsonCodecMaker {
               genWriteMapAsArray(q"x", writeVal1, writeVal2)
             } else genWriteMap(q"x", q"out.writeKey(kv._1)", writeVal2)
           }
-        } else if (tpe <:< typeOf[collection.Map[_, _]]) withEncoderFor(methodKey, m) {
+        } else if (tpe <:< typeOf[collection.Map[_, _]] || isCollisionProofHashMap(tpe)) withEncoderFor(methodKey, m) {
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)
           if (isScala213) {

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

@@ -1705,7 +1705,8 @@ object JsonCodecMaker {
             tpe <:< TypeRepr.of[mutable.LongMap[_]] || tpe <:< TypeRepr.of[immutable.Seq[_]] ||
             tpe <:< TypeRepr.of[Set[_]]) withNullValueFor(tpe) {
           scalaCollectionEmptyNoArgs(tpe, typeArg1(tpe)).asExprOf[T]
-        } else if (tpe <:< TypeRepr.of[collection.SortedMap[_, _]]) withNullValueFor(tpe) {
+        } else if (tpe <:< TypeRepr.of[collection.SortedMap[_, _]] ||
+            tpe <:< TypeRepr.of[mutable.CollisionProofHashMap[_, _]]) withNullValueFor(tpe) {
           val tpe1 = typeArg1(tpe)
           Apply(scalaMapEmptyNoArgs(tpe, tpe1, typeArg2(tpe)), List(summonOrdering(tpe1))).asExprOf[T]
         } else if (tpe <:< TypeRepr.of[immutable.Map[_, _]]) withNullValueFor(tpe) {
@@ -2310,14 +2311,15 @@ object JsonCodecMaker {
                 genReadMap(newBuilder, x => Assign(x.asTerm, '{ $x.updated($in.readKeyAsLong(), $readVal) }.asTerm).asExprOf[Unit],
                   identity, in, default.asExprOf[immutable.LongMap[t1]]).asExprOf[T]
               }
-        } else if (tpe <:< TypeRepr.of[mutable.Map[_, _]]) withDecoderFor(methodKey, default, in) { (in, default) =>
+        } else if (tpe <:< TypeRepr.of[mutable.Map[_, _]] ||
+            tpe <:< TypeRepr.of[mutable.CollisionProofHashMap[_, _]]) withDecoderFor(methodKey, default, in) { (in, default) =>
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)
           (tpe1.asType, tpe2.asType) match
             case ('[t1], '[t2]) =>
               val tDefault = default.asExprOf[T & mutable.Map[t1, t2]]
               val tEmpty =
-                if (tpe <:< TypeRepr.of[mutable.SortedMap[_, _]]) {
+                if (tpe <:< TypeRepr.of[mutable.SortedMap[_, _]] || tpe <:< TypeRepr.of[mutable.CollisionProofHashMap[_, _]]) {
                   Apply(scalaMapEmptyNoArgs(tpe, tpe1, tpe2), List(summonOrdering(tpe1))).asExprOf[T & mutable.Map[t1, t2]]
                 } else scalaMapEmptyNoArgs(tpe, tpe1, tpe2).asExprOf[T & mutable.Map[t1, t2]]
               val newBuilder = '{
@@ -2911,7 +2913,8 @@ object JsonCodecMaker {
                   genWriteMapAsArrayScala213(tx, writeVal1, writeVal2, out)
                 } else genWriteMapScala213(tx, (out, k) => '{ $out.writeKey($k) }, writeVal2, out)
               }
-        } else if (tpe <:< TypeRepr.of[collection.Map[_, _]]) withEncoderFor(methodKey, m, out) { (out, x) =>
+        } else if (tpe <:< TypeRepr.of[collection.Map[_, _]] ||
+            tpe <:< TypeRepr.of[mutable.CollisionProofHashMap[_, _]]) withEncoderFor(methodKey, m, out) { (out, x) =>
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)
           (tpe1.asType, tpe2.asType) match

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

@@ -0,0 +1,15 @@
+package com.github.plokhotnyuk.jsoniter_scala.macros
+
+import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker._
+
+class JsonCodecMakerNewTypeSpec extends VerifyingSpec {
+  import NamespacePollutions._
+
+  "JsonCodecMaker.make generate codecs which" should {
+    "serialize and deserialize new collection types" in {
+      verifySerDeser(make[_root_.scala.collection.mutable.CollisionProofHashMap[String, Int]],
+        _root_.scala.collection.mutable.CollisionProofHashMap[String, Int]("WWW" -> 1, "VVV" -> 2),
+        """{"WWW":1,"VVV":2}""")
+    }
+  }
+}

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

@@ -71,6 +71,11 @@ class JsonCodecMakerNewTypeSpec extends VerifyingSpec {
       verifySer(make[IArrayDefaults](CodecMakerConfig.withTransientEmpty(false)),
         IArrayDefaults(aa = IArray[IArray[Int]](), a = IArray[BigInt]()), """{"aa":[],"a":[]}""")
     }
+    "serialize and deserialize new collection types" in {
+      verifySerDeser(make[collection.mutable.CollisionProofHashMap[String, Int]],
+        collection.mutable.CollisionProofHashMap[String, Int]("WWW" -> 1, "VVV" -> 2),
+        """{"WWW":1,"VVV":2}""")
+    }
     "don't generate codecs for union types with proper compilation error" in {
       assert(intercept[TestFailedException](assertCompiles {
         """type ABC = "A" | "B" | "C"