Adds ability to pickle/unpickle things marked @transient

Author: heathermiller

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

@@ -258,8 +258,26 @@ trait UnpicklerMacros extends Macro {
 
       val someConstructorIsPrivate = ctors.exists(_.isPrivate)
       // println(s"someConstructorIsPrivate: $someConstructorIsPrivate")
-      val canCallCtor = !someConstructorIsPrivate && !cir.fields.exists(_.isErasedParam) && isPreciseType
-      // println(s"canCallCtor: $canCallCtor")
+      val canCallCtor = !someConstructorIsPrivate && !cir.fields.exists(_.isErasedParam) && isPreciseType && {
+        // there must not be a transient ctor param
+        // STEP 1: we need to figure out if there is a transient ctor param
+        val primaryCtor = tpe.declaration(nme.CONSTRUCTOR) match {
+          case overloaded: TermSymbol => overloaded.alternatives.head.asMethod // NOTE: primary ctor is always the first in the list
+          case primaryCtor: MethodSymbol => primaryCtor
+          case NoSymbol => NoSymbol
+        }
+
+        val allAccessors = tpe.declarations.collect { case meth: MethodSymbol if meth.isAccessor || meth.isParamAccessor => meth }
+
+        val (filteredAccessors, transientAccessors) = allAccessors.partition(irs.notMarkedTransient) // shoulsai iaobjsobj aaaobjsecta insteeyd  m d daybe
+
+        val hasTransientParam = (primaryCtor != NoSymbol) && primaryCtor.asMethod.paramss.flatten.exists { sym =>
+          transientAccessors.exists(acc => acc.name.toString == sym.name.toString)
+        }
+
+        !hasTransientParam
+      }
+      // STEP 2: remove transient fields from the "pending fields", the fields that need to be restored.
 
       // TODO: for ultimate loop safety, pendingFields should be hoisted to the outermost unpickling scope
       // For example, in the snippet below, when unpickling C, we'll need to move the b.c assignment not

core/src/main/scala/pickling/ir/IRs.scala

@@ -33,14 +33,43 @@ class IRs[U <: Universe with Singleton](val uni: U) {
   private type C = ClassIR
 
   // TODO: minimal versus verbose PickleFormat. i.e. someone might want all concrete inherited fields in their pickle
+
+  def notMarkedTransient(sym: TermSymbol): Boolean = {
+    //println(s"checking annots of ${sym.toString}...")
+    val tr = scala.util.Try {
+      if (sym.accessed != NoSymbol) {
+        val overall = sym.accessed.annotations.forall { a =>
+          val res = (a.tpe =:= typeOf[scala.transient])
+          !res
+        }
+        overall
+      } else true // if there is no backing field, then it cannot be marked transient
+    }
+    if (tr.isFailure) {
+    }
+    tr.isFailure || tr.get
+  }
+
+  /** Creates FieldIRs for the given type, tp.
+  */
   private def fields(tp: Type): Q = {
     val ctor = tp.declaration(nme.CONSTRUCTOR) match {
       case overloaded: TermSymbol => overloaded.alternatives.head.asMethod // NOTE: primary ctor is always the first in the list
       case primaryCtor: MethodSymbol => primaryCtor
       case NoSymbol => NoSymbol
     }
-    val ctorParams = if (ctor != NoSymbol) ctor.asMethod.paramss.flatten.map(_.asTerm) else Nil
-    val allAccessors = tp.declarations.collect{ case meth: MethodSymbol if meth.isAccessor || meth.isParamAccessor => meth }
+
+    val allAccessors = tp.declarations.collect { case meth: MethodSymbol if meth.isAccessor || meth.isParamAccessor => meth }
+
+    val (filteredAccessors, transientAccessors) = allAccessors.partition(notMarkedTransient)
+
+    val ctorParams = if (ctor != NoSymbol) ctor.asMethod.paramss.flatten.flatMap { sym =>
+      if (transientAccessors.exists(acc => acc.name.toString == sym.name.toString)) {
+        //println(s"found a BAD accessor: $sym")
+        List()
+      } else List(sym.asTerm)
+    } else Nil
+
     val (paramAccessors, otherAccessors) = allAccessors.partition(_.isParamAccessor)
 
     def mkFieldIR(sym: TermSymbol, param: Option[TermSymbol], accessor: Option[MethodSymbol]) = {
@@ -54,15 +83,16 @@ class IRs[U <: Universe with Singleton](val uni: U) {
     val varGetters = otherAccessors.collect{ case meth if meth.isGetter && meth.accessed != NoSymbol && meth.accessed.asTerm.isVar => meth }
     val varFields = varGetters.map(sym => mkFieldIR(sym, None, Some(sym)))
 
-    paramFields ++ varFields
+    val res = paramFields ++ varFields
+    res
   }
 
   private def composition(f1: (Q, Q) => Q, f2: (C, C) => C, f3: C => List[C]) =
     (c: C) => f3(c).reverse.reduce[C](f2)
 
   private val f1 = (q1: Q, q2: Q) => q1 ++ q2
 
-  private val f2 = (c1: C, c2: C) => ClassIR(c2.tpe, c1, fields(c2.tpe))
+  private val f2 = (c1: C, c2: C) => ClassIR(c2.tpe, c1, /*fields(c2.tpe)*/c2.fields) // here: fields is called a 2nd time.
 
   private val f3 = (c: C) =>
     c.tpe.baseClasses

core/src/test/scala/pickling/run/transient.scala

@@ -0,0 +1,19 @@
+package scala.pickling.transienttest
+
+import org.scalatest.FunSuite
+import scala.pickling._
+import json._
+
+case class Person(val name: String , @transient val ssNumber: Int) {
+  override def toString = s"Person($name)"
+}
+
+class TransientSimpleTest extends FunSuite {
+  test("main") {
+    val per = Person("Jenny", 123)
+    val p: JSONPickle = per.pickle
+    val up = p.unpickle[Person]
+    assert(up.ssNumber == 0)
+    assert(per.toString == up.toString)
+  }
+}