Handles transient now. Handles pickling ClassTags too. + tests

Author: heathermiller

core/src/main/scala/pickling/Compat.scala

@@ -85,6 +85,12 @@ object Compat {
     c.Expr[FastTypeTag[T]](bundle.impl[T])
   }
 
+  def FastTypeTagMacros_implClassTag[T: c.WeakTypeTag](c: Context): c.Expr[FastTypeTag[T]] = {
+    val c0: c.type = c
+    val bundle = new { val c: c0.type = c0 } with FastTypeTagMacros
+    c.Expr[FastTypeTag[T]](bundle.implClassTag[T])
+  }
+
   def FastTypeTagMacros_apply(c: Context)(key: c.Expr[String]): c.Expr[FastTypeTag[t]] forSome { type t } = {
     val c0: c.type = c
     val bundle = new { val c: c0.type = c0 } with FastTypeTagMacros

core/src/main/scala/pickling/FastTags.scala

@@ -5,6 +5,7 @@ import scala.reflect.macros.Context
 import scala.reflect.api.{Universe => ApiUniverse}
 import scala.reflect.runtime.{universe => ru}
 import language.experimental.macros
+import scala.reflect.ClassTag
 
 trait FastTypeTag[T] extends Equals {
   def mirror: ru.Mirror
@@ -19,6 +20,8 @@ trait FastTypeTag[T] extends Equals {
 object FastTypeTag {
   implicit def materializeFastTypeTag[T]: FastTypeTag[T] = macro Compat.FastTypeTagMacros_impl[T]
 
+  implicit def materializeFastTypeTagOfClassTag[T]: FastTypeTag[ClassTag[T]] = macro Compat.FastTypeTagMacros_implClassTag[T]
+
   private def stdTag[T: ru.TypeTag]: FastTypeTag[T] = apply(scala.reflect.runtime.currentMirror, ru.typeOf[T], ru.typeOf[T].key).asInstanceOf[FastTypeTag[T]]
   implicit val Null    = stdTag[Null]
   implicit val Byte    = stdTag[Byte]
@@ -108,6 +111,17 @@ trait FastTypeTagMacros extends Macro {
       }
     """
   }
+  def implClassTag[T: c.WeakTypeTag]: c.Tree = {
+    import c.universe._
+    val T = weakTypeOf[T]
+    q"""
+      new FastTypeTag[ClassTag[$T]] {
+        def mirror = scala.pickling.internal.`package`.currentMirror
+        lazy val tpe = scala.reflect.runtime.universe.weakTypeOf[ClassTag[$T]]
+        def key = "ClassTag[" + ${T.key} + "]"
+      }
+    """
+  }
   def apply(key: c.Tree): c.Tree = {
     import c.universe._
     q"""scala.pickling.FastTypeTag(scala.pickling.internal.`package`.currentMirror, $key)"""

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

@@ -35,17 +35,9 @@ class IRs[U <: Universe with Singleton](val uni: U) {
   // 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) {
+      (sym.accessed == NoSymbol) || // if there is no backing field, then it cannot be marked transient
+      !sym.accessed.annotations.exists(_.tpe =:= typeOf[scala.transient])
     }
     tr.isFailure || tr.get
   }

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

@@ -0,0 +1,21 @@
+package scala.pickling.implicitparams
+
+import org.scalatest.FunSuite
+import scala.pickling._
+import json._
+
+
+case class Person(implicit name: String, age: Int)
+object Test {
+  class SimpleImplParamTest extends FunSuite {
+    test("main") {
+      implicit val nme = "Harry"
+      implicit val age = 18
+
+      val per = Person()
+      val p = per.pickle
+      val up = p.unpickle[Person]
+      assert(per == up)
+    }
+  }
+}

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

@@ -1,13 +1,31 @@
 package scala.pickling.transienttest
 
 import org.scalatest.FunSuite
+import scala.reflect.ClassTag
 import scala.pickling._
 import json._
 
 case class Person(val name: String , @transient val ssNumber: Int) {
   override def toString = s"Person($name)"
 }
 
+class Dependency[T]
+
+class SparkConf(loadDefaults: Boolean)
+class SparkContext(config: SparkConf)
+
+class RDD[T: ClassTag](
+    @transient private var sc: SparkContext,
+    @transient private var deps: Seq[Dependency[_]]
+  )
+
+class RangePartitioner[K : ClassTag, V](
+    @transient val partitions: Int,
+    @transient val rdd: RDD[_ <: Product2[K,V]],
+    private var ascending: Boolean = true) {
+  override def toString = s"RangePartitioner(ascending = $ascending)"
+}
+
 class TransientSimpleTest extends FunSuite {
   test("main") {
     val per = Person("Jenny", 123)
@@ -16,4 +34,16 @@ class TransientSimpleTest extends FunSuite {
     assert(up.ssNumber == 0)
     assert(per.toString == up.toString)
   }
-}
+}
+
+class TransientSparkTest extends FunSuite {
+  test("main") {
+    val sc = new SparkContext(new SparkConf(true))
+    val rdd = new RDD[(Int, Int)](sc, Seq(new Dependency()))
+    val rp = new RangePartitioner[Int, Int](2, rdd)
+    val p: JSONPickle = rp.pickle
+    val up = p.unpickle[RangePartitioner[Int, Int]]
+    assert(rp.toString == up.toString)
+  }
+}
+