More efficient parsing of immutable maps

Author: plokhotnyuk

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

@@ -1773,6 +1773,18 @@ object JsonCodecMaker {
             val readVal1 = genReadVal(tpe1 :: types, genNullValue(tpe1 :: types), isStringified, EmptyTree)
             genReadMapAsArray(newBuilder, q"x.update($readVal1, { if (in.isNextToken(',')) $readVal2 else in.commaError() })")
           } else genReadMap(newBuilder, q"x.update(${genReadKey(tpe1 :: types)}, $readVal2)")
+        } else if (tpe <:< typeOf[immutable.Map[_, _]]) withDecoderFor(methodKey, default) {
+          val tpe1 = typeArg1(tpe)
+          val tpe2 = typeArg2(tpe)
+          val newBuilder = q"var x = ${withNullValueFor(tpe)(q"${scalaCollectionCompanion(tpe)}.empty[$tpe1, $tpe2]")}"
+          val readVal2 = genReadVal(tpe2 :: types, genNullValue(tpe2 :: types), isStringified, EmptyTree)
+          if (cfg.mapAsArray) {
+            val readVal1 = genReadVal(tpe1 :: types, genNullValue(tpe1 :: types), isStringified, EmptyTree)
+            genReadMapAsArray(newBuilder, q"x = x.updated($readVal1, { if (in.isNextToken(',')) $readVal2 else in.commaError() })")
+          } else {
+            val readKey = genReadKey(tpe1 :: types)
+            genReadMap(newBuilder, q"x = x.updated($readKey, $readVal2)")
+          }
         } else if (tpe <:< typeOf[collection.Map[_, _]]) withDecoderFor(methodKey, default) {
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)

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

@@ -2477,9 +2477,7 @@ object JsonCodecMaker {
                 if ($tDefault.isEmpty) $tDefault
                 else $tEmpty
               }.asExprOf[T & mutable.Map[t1, t2]]
-
-              def readVal2(using Quotes) = genReadVal(tpe2 :: types, genNullValue[t2](tpe2 :: types), isStringified, false, in)
-
+              val readVal2 = genReadVal(tpe2 :: types, genNullValue[t2](tpe2 :: types), isStringified, false, in)
               if (cfg.mapAsArray) {
                 val readVal1 = genReadVal(tpe1 :: types, genNullValue[t1](tpe1 :: types), isStringified, false, in)
                 genReadMapAsArray(newBuilder,
@@ -2489,25 +2487,42 @@ object JsonCodecMaker {
                 genReadMap(newBuilder, x => '{ $x.update(${genReadKey[t1](tpe1 :: types, in)}, $readVal2) },
                   identity, in, tDefault).asExprOf[T]
               }
+        } else if (tpe <:< TypeRepr.of[immutable.Map[?, ?]]) withDecoderFor(methodKey, default, in) { (in, default) =>
+          val tpe1 = typeArg1(tpe)
+          val tpe2 = typeArg2(tpe)
+          (tpe1.asType, tpe2.asType) match
+            case ('[t1], '[t2]) =>
+              lazy val readKey = genReadKey[t1](tpe1 :: types, in)
+              lazy val readVal1 = genReadVal(tpe1 :: types, genNullValue[t1](tpe1 :: types), isStringified, false, in)
+              val readVal2 = genReadVal(tpe2 :: types, genNullValue[t2](tpe2 :: types), isStringified, false, in)
+              val newBuilder =
+                (if (tpe <:< TypeRepr.of[immutable.SortedMap[?, ?]] || tpe <:< TypeRepr.of[immutable.TreeMap[?, ?]]) {
+                  Apply(scalaMapEmptyNoArgs(tpe, tpe1, tpe2), List(summonOrdering(tpe1)))
+                } else if (tpe <:< TypeRepr.of[immutable.TreeSeqMap[?, ?]]) {
+                  '{ immutable.TreeSeqMap.Empty.asInstanceOf[immutable.TreeSeqMap[t1, t2]] }.asTerm
+                } else withNullValueFor(tpe)(scalaMapEmptyNoArgs(tpe, tpe1, tpe2).asExprOf[T]).asTerm).asExprOf[T & immutable.Map[t1, t2]]
+              if (cfg.mapAsArray) {
+                genReadMapAsArray(newBuilder,
+                  x => Assign(x.asTerm, '{ $x.updated($readVal1, { if ($in.isNextToken(',')) $readVal2 else $in.commaError() })}.asTerm).asExprOf[Unit],
+                  identity, in, default.asExprOf[T & immutable.Map[t1, t2]]).asExprOf[T]
+              } else {
+                genReadMap(newBuilder,
+                  x => Assign(x.asTerm, '{ $x.updated($readKey, $readVal2) }.asTerm).asExprOf[Unit],
+                  identity, in, default.asExprOf[T & immutable.Map[t1, t2]]).asExprOf[T]
+              }
         } else if (tpe <:< TypeRepr.of[collection.Map[?, ?]]) withDecoderFor(methodKey, default, in) { (in, default) =>
           val tpe1 = typeArg1(tpe)
           val tpe2 = typeArg2(tpe)
           (tpe1.asType, tpe2.asType) match
             case ('[t1], '[t2]) =>
-              def builderNoApply =
+              val builderNoApply =
                 TypeApply(Select.unique(scalaCollectionCompanion(tpe), "newBuilder"), List(TypeTree.of[t1], TypeTree.of[t2]))
-
-              def readKey(using Quotes) = genReadKey[t1](tpe1 :: types, in)
-
-              def readVal2(using Quotes) = genReadVal(tpe2 :: types, genNullValue[t2](tpe2 :: types), isStringified, false, in)
-
-              def readVal1(using Quotes) = genReadVal(tpe1 :: types, genNullValue[t1](tpe1 :: types), isStringified, false, in)
-
+              lazy val readKey = genReadKey[t1](tpe1 :: types, in)
+              lazy val readVal1 = genReadVal(tpe1 :: types, genNullValue[t1](tpe1 :: types), isStringified, false, in)
+              val readVal2 = genReadVal(tpe2 :: types, genNullValue[t2](tpe2 :: types), isStringified, false, in)
               val newBuilder =
                 (if (tpe <:< TypeRepr.of[collection.SortedMap[?, ?]]) Apply(builderNoApply, List(summonOrdering(tpe1)))
-                else if (tpe <:< TypeRepr.of[immutable.TreeSeqMap[?, ?]]) '{ immutable.TreeSeqMap.newBuilder[t1, t2] }.asTerm
                 else builderNoApply).asExprOf[mutable.Builder[(t1, t2), T & collection.Map[t1, t2]]]
-
               if (cfg.mapAsArray) {
                 genReadMapAsArray(newBuilder,
                   x => '{ $x.addOne(new Tuple2($readVal1, { if ($in.isNextToken(',')) $readVal2 else $in.commaError() })): Unit},