Static pickler should not attempt to pickle non-existing fields

In static pickler, don't attempt to pickle a private field that
is not one of the declared fields according to Java reflection.

Also adds another test.

Author: phaller

core/src/main/scala/pickling/Macros.scala

@@ -111,34 +111,40 @@ trait PicklerMacros extends Macro {
         // for each field, compute a tree for pickling it
         // (or empty list, if impossible)
 
-        def putField(getterLogic: Tree) = {
-          def wrap(pickleLogic: Tree) = q"builder.putField(${fir.name}, b => $pickleLogic)"
-          wrap {
-            if (fir.tpe.typeSymbol.isEffectivelyFinal) q"""
-              b.hintStaticallyElidedType()
-              $getterLogic.pickleInto(b)
-            """ else q"""
-              val subPicklee: ${fir.tpe} = $getterLogic
-              if (subPicklee == null || subPicklee.getClass == classOf[${fir.tpe}]) b.hintDynamicallyElidedType() else ()
-              subPicklee.pickleInto(b)
-            """
-          }
+        def pickleLogic(fieldValue: Tree): Tree =
+          if (fir.tpe.typeSymbol.isEffectivelyFinal) q"""
+            b.hintStaticallyElidedType()
+            $fieldValue.pickleInto(b)
+          """ else q"""
+            val subPicklee: ${fir.tpe} = $fieldValue
+            if (subPicklee == null || subPicklee.getClass == classOf[${fir.tpe}]) b.hintDynamicallyElidedType()
+            subPicklee.pickleInto(b)
+          """
+
+        def putField(getterLogic: Tree) =
+          q"builder.putField(${fir.name}, b => ${pickleLogic(getterLogic)})"
+
+        // we assume getterLogic is a tree of type Try[${fir.tpe}]
+        def tryPutField(getterLogic: Tree) = {
+          val tryName = c.fresh(newTermName("tr"))
+          val valName = c.fresh(newTermName("value"))
+          q"""
+            val $tryName = $getterLogic
+            if ($tryName.isSuccess) {
+              val $valName = $tryName.get
+              builder.putField(${fir.name}, b => ${pickleLogic(Ident(valName))})
+            }
+          """
         }
 
         if (sym.isModuleClass) {
           Nil
         } else if (fir.hasGetter) {
-
           if (fir.isPublic) List(putField(q"picklee.${newTermName(fir.name)}"))
           else reflectively("picklee", fir)(fm => putField(q"$fm.get.asInstanceOf[${fir.tpe}]"))
         } else {
-          //val clazz = universe.mirror.runtimeClass(tpe.erasure)
-          //if (Try(clazz.getDeclaredField(fir.name)).isSuccess) {
-            // pickle field using reflection
-            reflectivelyWithoutGetter("picklee", fir)(fvalue => putField(q"$fvalue.asInstanceOf[${fir.tpe}]"))
-          /*} else {
-            Nil
-          }*/
+          reflectivelyWithoutGetter("picklee", fir)(fvalue =>
+            tryPutField(q"$fvalue.asInstanceOf[scala.util.Try[${fir.tpe}]]"))
         }
       })
       val endEntry = q"builder.endEntry()"
@@ -267,11 +273,12 @@ trait UnpicklerMacros extends Macro {
       // nevertheless don't despair and try to prove whether this is or is not the fact
       // i was super scared that string sharing is going to fail due to the same reason, but it did not :)
       // in the worst case we can do the same as the interpreted runtime does - just go for allocateInstance
-      val pendingFields = cir.fields.filter(fir =>
-        fir.isNonParam ||
-        (!canCallCtor && fir.isReifiedParam) ||
-        shouldBotherAboutLooping(fir.tpe)
+
+      // pending fields are fields that are restored after instantiation (e.g., through field assignments)
+      val pendingFields = if (!canCallCtor) cir.fields else cir.fields.filter(fir =>
+        fir.isNonParam || shouldBotherAboutLooping(fir.tpe)
       )
+
       val instantiationLogic = {
         if (sym.isModuleClass) {
           q"${sym.module}"
@@ -304,7 +311,15 @@ trait UnpicklerMacros extends Macro {
           val initPendingFields = pendingFields.flatMap(fir => {
             val readFir = readField(fir.name, fir.tpe)
             if (fir.isPublic && fir.hasSetter) List(q"$instance.${newTermName(fir.name)} = $readFir".asInstanceOf[Tree])
-            else if (fir.accessor.isEmpty) List()
+            else if (fir.accessor.isEmpty) List(q"""
+              try {
+                val javaField = $instance.getClass.getDeclaredField(${fir.name})
+                javaField.setAccessible(true)
+                javaField.set($instance, $readFir)
+              } catch {
+                case e: java.lang.NoSuchFieldException => /* do nothing */
+              }
+            """)
             else reflectively(instance, fir)(fm => q"$fm.set($readFir)".asInstanceOf[Tree])
           })
 

core/src/main/scala/pickling/Runtime.scala

@@ -227,9 +227,9 @@ class InterpretedUnpicklerRuntime(mirror: Mirror, tag: FastTypeTag[_])(implicit
           if (shouldBotherAboutSharing(tpe)) registerUnpicklee(inst, preregisterUnpicklee())
           val im = mirror.reflect(inst)
 
-          debug(s"pendingFields: ${pendingFields.size}")
-          debug(s"fieldVals: ${fieldVals.size}")
-          
+          //debug(s"pendingFields: ${pendingFields.size}")
+          //debug(s"fieldVals: ${fieldVals.size}")
+
           pendingFields.zip(fieldVals) foreach {
             case (fir, fval) =>
               if (fir.hasGetter) {

core/src/main/scala/pickling/RuntimePickler.scala

@@ -133,14 +133,13 @@ class RuntimePickler(classLoader: ClassLoader, clazz: Class[_])(implicit pf: Pic
       val format: PickleFormat = pf
 
       val fields: List[Logic] = cir.fields.flatMap { fir =>
-        if (fir.hasGetter) {
-          //debug(s"pickling field of type ${fir.tpe.key}")
+        if (fir.hasGetter)
           List(
             if (fir.tpe.typeSymbol.isEffectivelyFinal) new EffectivelyFinalLogic(fir)
             else if (fir.tpe.typeSymbol.asType.isAbstractType) new AbstractLogic(fir)
             else new DefaultLogic(fir)
           )
-        } else
+        else
           try {
             val javaField = clazz.getDeclaredField(fir.name)
             List(
@@ -151,32 +150,14 @@ class RuntimePickler(classLoader: ClassLoader, clazz: Class[_])(implicit pf: Pic
             case e: java.lang.NoSuchFieldException => List()
           }
       }
-/*
-      {
-        debug(s"cir.fields: ${cir.fields.mkString(",")}")
-
-        val regularFields = cir.fields.filter(_.hasGetter)
-        debug(s"regular fields with getters: ${regularFields.mkString(",")}")
-
-        val ctorParamsWithoutGetter =
-          clazz.getDeclaredFields().filter(df => regularFields.forall(_.name != df.getName))
-        debug(s"ctor params without getters: ${ctorParamsWithoutGetter.mkString(",")}")
-
-        ctorParamsWithoutGetter.map(cp => new CtorParamLogic(cp)).toList ++ regularFields.map { fir =>
-          debug(s"pickling field of type ${fir.tpe.key}")
-          if (fir.tpe.typeSymbol.isEffectivelyFinal) new EffectivelyFinalLogic(fir)
-          else if (fir.tpe.typeSymbol.asType.isAbstractType) new AbstractLogic(fir)
-          else new DefaultLogic(fir)
-        }
-      }
-*/
+
       def putFields(picklee: Any, builder: PBuilder): Unit = {
         val im = mirror.reflect(picklee)
         fields.foreach(_.run(builder, picklee, im))
       }
 
       def pickle(picklee: Any, builder: PBuilder): Unit = {
-        debug(s"pickling object of type: ${tag.key}")
+        //debug(s"pickling object of type: ${tag.key}")
         builder.beginEntry(picklee)
         putFields(picklee, builder)
         builder.endEntry()

core/src/main/scala/pickling/Tools.scala

@@ -379,9 +379,10 @@ abstract class Macro { self =>
     val pickleeName = newTermName(target)
     val getFieldValue = q"""
       val clazz = $pickleeName.getClass
-      val javaField: java.lang.reflect.Field = clazz.getDeclaredField(${fir.name})
-      javaField.setAccessible(true)
-      javaField.get($pickleeName)
+      scala.util.Try(clazz.getDeclaredField(${fir.name})).map { javaField =>
+        javaField.setAccessible(true)
+        javaField.get($pickleeName)
+      }
     """
     List(body(getFieldValue))
   }

core/src/test/scala/pickling/run/ctor-params.scala

@@ -1,4 +1,4 @@
-package scala.pickling.ctorparams
+package scala.pickling.test.ctorparams
 
 import org.scalatest.FunSuite
 import scala.pickling._
@@ -9,21 +9,30 @@ class Partitioner(numParts: Int) {
   override def toString = s"Partitioner($numParts)"
 }
 
-class AllRuntimeCtorsParamTest extends FunSuite {
-  test("main") {
+class Partitioner2(numParts: Int, val other: String) {
+  def numPartitions = numParts
+  override def toString = s"Partitioner2($numParts,$other)"
+}
+
+class CtorParamsTest extends FunSuite {
+  test("runtime pickler") {
     val par: Any = new Partitioner(8)
     val p: JSONPickle = par.pickle
     val up = p.unpickle[Any]
     assert(par.toString == up.toString)
   }
-}
 
-class StaticTriggeredCtorsParamTest extends FunSuite {
-  test("main") {
-    // val par = new Partitioner(8)
-    // val p: JSONPickle = par.pickle
-    // val up = p.unpickle[Partitioner]
-    // assert(par.toString == up.toString)
-    assert(true)
+  test("static pickler") {
+    val par = new Partitioner(8)
+    val p: JSONPickle = par.pickle
+    val up = p.unpickle[Partitioner]
+    assert(par.toString == up.toString)
   }
-}
+
+  test("ctor param and public getter") {
+    val par = new Partitioner2(8, "test")
+    val p: JSONPickle = par.pickle
+    val up = p.unpickle[Partitioner2]
+    assert(par.toString == up.toString)
+  }
+}