Fix SizedCodec.size marco code when handling IgnoreTransientDefaultMarker

Author: sebaciv

core/src/test/scala/com/avsystem/commons/serialization/ObjectSizeTest.scala

@@ -25,10 +25,30 @@ object CustomWrapper extends HasApplyUnapplyCodec[CustomWrapper] {
   def unapply(cw: CustomWrapper): Opt[String] = Opt(cw.a)
 }
 
+case class RecordWithOpts(
+  @optionalParam abc: Opt[String] = Opt.Empty,
+  @transientDefault flag: Opt[Boolean] = Opt.Empty,
+  b: Int = 42,
+)
+object RecordWithOpts extends HasApplyUnapplyCodec[RecordWithOpts]
+
+case class SingleFieldRecordWithOpts(@optionalParam abc: Opt[String] = Opt.Empty)
+object SingleFieldRecordWithOpts extends HasApplyUnapplyCodec[SingleFieldRecordWithOpts]
+
+case class SingleFieldRecordWithTD(@transientDefault abc: String = "abc")
+object SingleFieldRecordWithTD extends HasApplyUnapplyCodec[SingleFieldRecordWithTD]
+
 class ObjectSizeTest extends AnyFunSuite {
   test("computing object size") {
     assert(RecordWithDefaults.codec.size(RecordWithDefaults()) == 2)
     assert(RecordWithDefaults.codec.size(RecordWithDefaults("fuu")) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt)) == 2)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt, true.opt)) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts()) == 1)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts()) == 0)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts("abc".opt)) == 1)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD()) == 0)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD("haha")) == 1)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults()) == 1)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults("fuu")) == 2)
     assert(CustomWrapper.codec.size(CustomWrapper()) == 0)
@@ -46,6 +66,13 @@ class ObjectSizeTest extends AnyFunSuite {
     }
     assert(RecordWithDefaults.codec.size(RecordWithDefaults(), defaultIgnoringOutput.opt) == 3)
     assert(RecordWithDefaults.codec.size(RecordWithDefaults("fuu"), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts("abc".opt, true.opt), defaultIgnoringOutput.opt) == 3)
+    assert(RecordWithOpts.codec.size(RecordWithOpts(), defaultIgnoringOutput.opt) == 2)
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts(), defaultIgnoringOutput.opt) == 0) // @optionalParam field should NOT be counted
+    assert(SingleFieldRecordWithOpts.codec.size(SingleFieldRecordWithOpts("abc".opt), defaultIgnoringOutput.opt) == 1)
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD(), defaultIgnoringOutput.opt) == 1) // @transientDefault field should be counted
+    assert(SingleFieldRecordWithTD.codec.size(SingleFieldRecordWithTD("haha"), defaultIgnoringOutput.opt) == 1)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults(), defaultIgnoringOutput.opt) == 2)
     assert(CustomRecordWithDefaults.codec.size(CustomRecordWithDefaults("fuu"), defaultIgnoringOutput.opt) == 2)
   }

macros/src/main/scala/com/avsystem/commons/macros/serialization/GenCodecMacros.scala

@@ -251,38 +251,66 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
     def anyParamHasTransientDefault: Boolean =
       params.exists(isTransientDefault)
 
+    def isOptionLike(p: ApplyParam): Boolean =
+      p.optionLike.nonEmpty
+
     def mayBeTransient(p: ApplyParam): Boolean =
-      p.optionLike.nonEmpty || isTransientDefault(p)
+      isOptionLike(p) || isTransientDefault(p)
 
     def transientValue(p: ApplyParam): Tree = p.optionLike match {
       case Some(optionLike) => q"${optionLike.reference(Nil)}.none"
       case None => p.defaultValue
     }
 
-    def countTransientFields: Tree =
+    // assumes usage in in size(value, output) method implementation
+    def countTransientFields: Tree = {
+      def checkIgnoreTransientDefaultMarker: Tree =
+        q"output.isDefined && output.get.customEvent($SerializationPkg.IgnoreTransientDefaultMarker, ())"
+
+      def doCount(paramsToCount: List[ApplyParam], accessor: ApplyParam => Tree): Tree =
+        paramsToCount.foldLeft[Tree](q"0") {
+          (acc, p) => q"$acc + (if(${accessor(p)} == ${transientValue(p)}) 1 else 0)"
+        }
+
+      def countOnlyOptionLike(accessor: ApplyParam => Tree): Tree =
+        doCount(params.filter(isOptionLike), accessor)
+
+      def countTransient(accessor: ApplyParam => Tree): Tree =
+        doCount(params.filter(mayBeTransient), accessor)
+
+      def countMultipleParams(accessor: ApplyParam => Tree): Tree =
+        if (anyParamHasTransientDefault)
+          q"if($checkIgnoreTransientDefaultMarker) ${countOnlyOptionLike(accessor)} else ${countTransient(accessor)}"
+        else
+          countTransient(accessor)
+
+      def countSingleParam(param: ApplyParam, value: Tree): Tree =
+        if (isTransientDefault(param))
+          q"if(!$checkIgnoreTransientDefaultMarker && $value == ${transientValue(param)}) 1 else 0"
+        else
+          q"if($value == ${transientValue(param)}) 1 else 0"
+
       if (canUseFields)
-        params.filter(mayBeTransient).foldLeft[Tree](q"0") {
-          (acc, p) => q"$acc + (if(value.${p.sym.name} == ${transientValue(p)}) 1 else 0)"
+        countMultipleParams(p => q"value.${p.sym.name}")
+      else if (!params.exists(mayBeTransient))
+        q"0"
+      else
+        params match {
+          case List(p: ApplyParam) =>
+            q"""
+              val unapplyRes = $companion.$unapply[..${dtpe.typeArgs}](value)
+              if(unapplyRes.isEmpty) unapplyFailed else { ${countSingleParam(p, q"unapplyRes.get")} }
+             """
+          case _ =>
+            q"""
+              val unapplyRes = $companion.$unapply[..${dtpe.typeArgs}](value)
+              if(unapplyRes.isEmpty) unapplyFailed else {
+                val t = unapplyRes.get
+                ${countMultipleParams(p => q"t.${tupleGet(p.idx)}")}
+              }
+             """
         }
-      else if (!params.exists(mayBeTransient)) q"0"
-      else params match {
-        case List(p: ApplyParam) =>
-          q"""
-            val unapplyRes = $companion.$unapply[..${dtpe.typeArgs}](value)
-            if(unapplyRes.isEmpty) unapplyFailed else if(unapplyRes.get == ${transientValue(p)}) 1 else 0
-          """
-        case _ =>
-          val res = params.filter(mayBeTransient).foldLeft[Tree](q"0") {
-            (acc, p) => q"$acc + (if(t.${tupleGet(p.idx)} == ${transientValue(p)}) 1 else 0)"
-          }
-          q"""
-            val unapplyRes = $companion.$unapply[..${dtpe.typeArgs}](value)
-            if(unapplyRes.isEmpty) unapplyFailed else {
-              val t = unapplyRes.get
-              $res
-            }
-           """
-      }
+    }
 
     if (isTransparent(dtpe.typeSymbol)) params match {
       case List(p: ApplyParam) =>
@@ -331,7 +359,7 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
         val res =
           q"""
             def size(value: $dtpe, output: $OptCls[$SerializationPkg.SequentialOutput]): $IntCls =
-              ${params.size} + ${generated.size} - output.filter(_.customEvent($SerializationPkg.IgnoreTransientDefaultMarker, ())).mapOr($countTransientFields, _ => 0)
+              ${params.size} + ${generated.size} - { $countTransientFields }
           """
         List(res)
       }