Merge pull request #118 from phaller/topic/2.11

Enable cross compilation

Author: heathermiller

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

@@ -13,6 +13,11 @@ import scala.collection.generic.CanBuildFrom
 
 // this is only necessary because 2.10.x doesn't support macro bundles
 object Compat {
+  // provides a source compatibility stub
+  implicit class HasPt[A, B](t: (A, B)) {
+    def pt: A = t._1
+  }
+
   def PicklerMacros_impl[T: c.WeakTypeTag](c: Context)(format: c.Expr[PickleFormat]): c.Expr[SPickler[T]] = {
     val c0: c.type = c
     val bundle = new { val c: c0.type = c0 } with PicklerMacros
@@ -91,24 +96,9 @@ object Compat {
     c.Expr[FastTypeTag[T]](bundle.impl[T])
   }
 
-  def FastTypeTagMacros_apply(c: Context)(key: c.Expr[String]): c.Expr[FastTypeTag[_]] = {
+  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
-    c.Expr[FastTypeTag[_]](bundle.apply(key.tree))
-  }
-}
-
-trait Reflection211Compat { self: Macro =>
-  val c: Context
-  import c.universe._
-
-  object TermName {
-    def apply(s: String) = newTermName(s)
-    def unapply(name: TermName): Option[String] = Some(name.toString)
-  }
-
-  object TypeName {
-    def apply(s: String) = newTypeName(s)
-    def unapply(name: TypeName): Option[String] = Some(name.toString)
+    c.Expr(bundle.apply(key.tree))
   }
 }

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

@@ -30,7 +30,7 @@ trait PicklerMacros extends Macro {
     )
 
     def getField(fir: FieldIR): Tree =
-      if (fir.isPublic) q"picklee.${TermName(fir.name)}"
+      if (fir.isPublic) q"picklee.${newTermName(fir.name)}"
       else reflectively("picklee", fir)(fm => q"$fm.get.asInstanceOf[${fir.tpe}]").head //TODO: don't think it's possible for this to return an empty list, so head should be OK
 
     // this exists so as to provide as much information as possible about the size of the object
@@ -103,7 +103,7 @@ trait PicklerMacros extends Macro {
               """
             }
           }
-          if (fir.isPublic) List(putField(q"picklee.${TermName(fir.name)}"))
+          if (fir.isPublic) List(putField(q"picklee.${newTermName(fir.name)}"))
           else reflectively("picklee", fir)(fm => putField(q"$fm.get.asInstanceOf[${fir.tpe}]"))
         } else {
           // NOTE: this means that we've encountered a primary constructor parameter elided in the "constructors" phase
@@ -131,7 +131,7 @@ trait PicklerMacros extends Macro {
         """
       }
     }
-    def pickleLogic = tpe match {
+    def pickleLogic: Tree = tpe match {
       case NothingTpe => c.abort(c.enclosingPosition, "cannot pickle Nothing") // TODO: report the serialization path that brought us here
       case _ => unifiedPickle
     }
@@ -176,13 +176,16 @@ trait PicklerMacros extends Macro {
   }
 }
 
+import HasCompat._
+
 // purpose of this macro: implementation of genUnpickler[T]. i.e., the macro that is selected via implicit
 // search and which initiates the process of generating an unpickler for a given type T.
 // NOTE: dispatch is done elsewhere. unpicklers generated by genUnpickler[T] only know how to process T
 // but not its subclasses or the types convertible to it!
 trait UnpicklerMacros extends Macro {
   def impl[T: c.WeakTypeTag](format: c.Tree): c.Tree = preferringAlternativeImplicits {
     import c.universe._
+    import compat._
     import definitions._
     val tpe = weakTypeOf[T]
     val targs = tpe match { case TypeRef(_, _, targs) => targs; case _ => Nil }
@@ -240,11 +243,11 @@ trait UnpicklerMacros extends Macro {
         if (sym.isModuleClass || pendingFields.isEmpty) {
           instantiationLogic
         } else {
-          val instance = TermName(tpe.typeSymbol.name + "Instance")
+          val instance = newTermName(tpe.typeSymbol.name + "Instance")
 
           val initPendingFields = pendingFields.flatMap(fir => {
             val readFir = readField(fir.name, fir.tpe)
-            if (fir.isPublic && fir.hasSetter) List(q"$instance.${TermName(fir.name)} = $readFir".asInstanceOf[Tree])
+            if (fir.isPublic && fir.hasSetter) List(q"$instance.${newTermName(fir.name)} = $readFir".asInstanceOf[Tree])
             else if (fir.accessor.isEmpty) List()
             else reflectively(instance, fir)(fm => q"$fm.set($readFir)".asInstanceOf[Tree])
           })
@@ -352,7 +355,7 @@ trait PickleMacros extends Macro {
     def nonFinalDispatch = {
       val nullDispatch = CaseDef(Literal(Constant(null)), EmptyTree, createPickler(NullTpe, builder))
       val compileTimeDispatch = compileTimeDispatchees(tpe) filter (_ != NullTpe) map (subtpe =>
-        CaseDef(Bind(TermName("clazz"), Ident(nme.WILDCARD)), q"clazz == classOf[$subtpe]", createPickler(subtpe, builder))
+        CaseDef(Bind(newTermName("clazz"), Ident(nme.WILDCARD)), q"clazz == classOf[$subtpe]", createPickler(subtpe, builder))
       )
       //TODO OPTIMIZE: do getClass.getClassLoader only once
       val runtimeDispatch = CaseDef(Ident(nme.WILDCARD), EmptyTree, q"SPickler.genPickler(this.getClass.getClassLoader, clazz)")

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

@@ -2,9 +2,7 @@ package scala.pickling
 
 import scala.pickling.internal._
 
-import scala.reflect.runtime.universe._
-import definitions._
-import scala.reflect.runtime.{universe => ru}
+import scala.reflect.runtime.universe.Mirror
 import ir._
 
 object Runtime {
@@ -22,7 +20,18 @@ object Runtime {
   )
 }
 
+// provides a source compatibility stub
+// in Scala 2.10.x, it will make `import compat._` compile just fine,
+// even though `c.universe` doesn't have `compat`
+// in Scala 2.11.0, it will be ignored, becase `import c.universe._`
+// brings its own `compat` in scope and that one takes precedence
+private object HasCompat { val compat = ??? }; import HasCompat._
+
 abstract class PicklerRuntime(classLoader: ClassLoader, preclazz: Class[_], share: refs.Share) {
+  import scala.reflect.runtime.universe._
+  import definitions._
+  import scala.reflect.runtime.{universe => ru}
+  import compat._
 
   val clazz = if (preclazz != null) Runtime.toUnboxed.getOrElse(preclazz, preclazz) else null
   val mirror = runtimeMirror(classLoader)
@@ -60,6 +69,7 @@ abstract class PicklerRuntime(classLoader: ClassLoader, preclazz: Class[_], shar
 }
 
 class InterpretedPicklerRuntime(classLoader: ClassLoader, preclazz: Class[_])(implicit share: refs.Share) extends PicklerRuntime(classLoader, preclazz, share) {
+  import scala.reflect.runtime.universe._
 
   debug("InterpretedPicklerRuntime: preclazz = " + preclazz)
   debug("InterpretedPicklerRuntime: clazz    = " + clazz)
@@ -143,6 +153,10 @@ class InterpretedPicklerRuntime(classLoader: ClassLoader, preclazz: Class[_])(im
 // TODO: currently this works with an assumption that sharing settings for unpickling are the same as for pickling
 // of course this might not be the case, so we should be able to read `share` from the pickle itself
 class InterpretedUnpicklerRuntime(mirror: Mirror, tag: FastTypeTag[_])(implicit share: refs.Share) {
+  import scala.reflect.runtime.universe._
+  import definitions._
+  import scala.reflect.runtime.{universe => ru}
+
   val tpe = tag.tpe
   val sym = tpe.typeSymbol.asType
   debug("UnpicklerRuntime: tpe = " + tpe)

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

@@ -6,14 +6,14 @@ import scala.language.existentials
 
 import scala.reflect.macros.Context
 import scala.reflect.api.Universe
-import scala.reflect.runtime.universe._
-import scala.reflect.runtime.{universe => ru}
 
 import scala.collection.mutable.{Map => MutableMap, ListBuffer => MutableList, WeakHashMap, Set => MutableSet}
 import scala.collection.mutable.{Stack => MutableStack, Queue => MutableQueue}
 
 import java.lang.ref.WeakReference
 
+import HasCompat._
+
 object Tools {
   private val subclassCaches = new WeakHashMap[AnyRef, WeakReference[AnyRef]]()
 
@@ -44,6 +44,7 @@ object Tools {
 class Tools[C <: Context](val c: C) {
   val u: c.universe.type = c.universe
   import u._
+  import compat._
   import definitions._
 
   def blackList(sym: Symbol) = sym == AnyClass || sym == AnyRefClass || sym == AnyValClass || sym == ObjectClass
@@ -238,9 +239,10 @@ abstract class ShareAnalyzer[U <: Universe](val u: U) {
   }
 }
 
-abstract class Macro extends Reflection211Compat { self =>
+abstract class Macro { self =>
   val c: Context
   import c.universe._
+  import compat._
   import definitions._
   val RefTpe = weakTypeOf[refs.Ref]
 
@@ -258,7 +260,7 @@ abstract class Macro extends Reflection211Compat { self =>
   private def innerType(target: Tree, name: String): Type = {
     def fail(msg: String) = c.abort(c.enclosingPosition, s"$msg for ${target} of type ${target.tpe}")
     // val carrier = c.typeCheck(tq"${target.tpe}#${TypeName(name)}", mode = c.TYPEmode, silent = true)
-    val carrier = c.typeCheck(q"{ val x: ${target.tpe}#${TypeName(name)} = ??? }", silent = true)
+    val carrier = c.typeCheck(q"{ val x: ${target.tpe}#${newTypeName(name)} = ??? }", silent = true)
     carrier match {
       case EmptyTree => fail(s"Couldn't resolve $name")
       case Block(ValDef(_, _, tpt, _) :: _, _) => tpt.tpe.normalize match {
@@ -316,10 +318,10 @@ abstract class Macro extends Reflection211Compat { self =>
   def syntheticPackageName: String = "scala.pickling.synthetic"
   def syntheticBaseName(tpe: Type): TypeName = {
     val raw = tpe.key.split('.').map(_.capitalize).mkString("")
-    val encoded = TypeName(raw).encoded
-    TypeName(encoded)
+    val encoded = newTypeName(raw).encoded
+    newTypeName(encoded)
   }
-  def syntheticBaseQualifiedName(tpe: Type): TypeName = TypeName(syntheticPackageName + "." + syntheticBaseName(tpe).toString)
+  def syntheticBaseQualifiedName(tpe: Type): TypeName = newTypeName(syntheticPackageName + "." + syntheticBaseName(tpe).toString)
 
   def syntheticPicklerName(tpe: Type): TypeName = syntheticBaseName(tpe) + syntheticPicklerSuffix()
   def syntheticPicklerQualifiedName(tpe: Type): TypeName = syntheticBaseQualifiedName(tpe) + syntheticPicklerSuffix()
@@ -334,35 +336,44 @@ abstract class Macro extends Reflection211Compat { self =>
   def syntheticPicklerUnpicklerSuffix(): String = "PicklerUnpickler"
 
   def preferringAlternativeImplicits(body: => Tree): Tree = {
+    import Compat._
+
+    val candidates = c.enclosingImplicits
+    val ourPt      = candidates.head.pt
+
     def debug(msg: Any) = {
-      val padding = "  " * (c.enclosingImplicits.length - 1)
+      val padding = "  " * (candidates.length - 1)
       // Console.err.println(padding + msg)
     }
-    debug("can we enter " + c.enclosingImplicits.head._1 + "?")
-    debug(c.enclosingImplicits)
-    c.enclosingImplicits match {
-      case (ourPt, _) :: (theirPt, _) :: _ if ourPt =:= theirPt =>
-        debug(s"no, because: ourPt = $ourPt, theirPt = $theirPt")
-        // c.diverge()
-        c.abort(c.enclosingPosition, "stepping aside: repeating itself")
-      case _ =>
-        debug(s"not sure, need to explore alternatives")
-        c.inferImplicitValue(c.enclosingImplicits.head._1, silent = true) match {
-          case success if success != EmptyTree =>
-            debug(s"no, because there's $success")
-            c.abort(c.enclosingPosition, "stepping aside: there are other candidates")
-            // c.diverge()
-          case _ =>
-            debug("yes, there are no obstacles. entering " + c.enclosingImplicits.head._1)
-            val result = body
-            debug("result: " + result)
-            result
-        }
+
+    debug("can we enter " + ourPt + "?")
+    debug(candidates)
+
+    if ((candidates.size >= 2) && {
+      val theirPt = candidates.tail.head.pt
+      ourPt =:= theirPt
+    }) {
+      debug(s"no, because: ourPt = $ourPt, theirPt = ${candidates.tail.head.pt}")
+      // c.diverge()
+      c.abort(c.enclosingPosition, "stepping aside: repeating itself")
+    } else {
+      debug(s"not sure, need to explore alternatives")
+      c.inferImplicitValue(ourPt, silent = true) match {
+        case success if success != EmptyTree =>
+          debug(s"no, because there's $success")
+          c.abort(c.enclosingPosition, "stepping aside: there are other candidates")
+          // c.diverge()
+        case _ =>
+          debug("yes, there are no obstacles. entering " + ourPt)
+          val result = body
+          debug("result: " + result)
+          result
+      }
     }
   }
 
   private var reflectivePrologueEmitted = false // TODO: come up with something better
-  def reflectively(target: String, fir: FieldIR)(body: Tree => Tree): List[Tree] = reflectively(TermName(target), fir)(body)
+  def reflectively(target: String, fir: FieldIR)(body: Tree => Tree): List[Tree] = reflectively(newTermName(target), fir)(body)
 
   /**
    *  requires: !fir.accessor.isEmpty
@@ -382,8 +393,8 @@ abstract class Macro extends Reflection211Compat { self =>
       }
     }
     val field = fir.field.get
-    val ownerSymbol = TermName(fir.name + "Owner")
-    val firSymbol = TermName(fir.name + "Symbol")
+    val ownerSymbol = newTermName(fir.name + "Owner")
+    val firSymbol = newTermName(fir.name + "Symbol")
     // TODO: make sure this works for:
     // 1) private[this] fields
     // 2) inherited private[this] fields
@@ -427,6 +438,8 @@ trait PickleTools {
 }
 
 trait CurrentMirrorMacro extends Macro {
+  import scala.reflect.runtime.{universe => ru}
+
   def impl: c.Tree = {
     import c.universe._
     c.inferImplicitValue(typeOf[ru.Mirror], silent = true) orElse {

core/src/main/scala/pickling/internal/package.scala

@@ -3,11 +3,14 @@ package scala.pickling
 import scala.language.experimental.macros
 import scala.language.reflectiveCalls
 
-import scala.reflect.runtime.{universe => ru}
-import ru._
+import HasCompat._
 
 package object internal {
 
+  import scala.reflect.runtime.{universe => ru}
+  import ru._
+  import compat._
+
   // TOGGLE DEBUGGING
   private val debugEnabled: Boolean = System.getProperty("pickling.debug", "false").toBoolean
   private[pickling] def debug(output: => String) = if (debugEnabled) println(output)

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

@@ -3,8 +3,11 @@ package ir
 
 import scala.reflect.api.Universe
 
+import HasCompat._
+
 class IRs[U <: Universe with Singleton](val uni: U) {
   import uni._
+  import compat._
   import definitions._
 
   sealed abstract class PickleIR

project/Build.scala

@@ -12,7 +12,6 @@ object BuildSettings {
   val buildSettings = Defaults.defaultSettings ++ Seq(
     version := buildVersion,
     scalaVersion := buildScalaVersion,
-    addCompilerPlugin("org.scala-lang.plugins" % "macro-paradise" % "2.0.0-SNAPSHOT" cross CrossVersion.full),
     resolvers += Resolver.sonatypeRepo("snapshots"),
     resolvers += Resolver.sonatypeRepo("releases"),
     scalacOptions ++= Seq("-feature")
@@ -73,8 +72,21 @@ object MyBuild extends Build {
     settings = buildSettings ++ Seq(
       scalacOptions ++= Seq("-optimise"),
       libraryDependencies <+= (scalaVersion)("org.scala-lang" % "scala-reflect" % _),
-      libraryDependencies += "org.scalatest" %% "scalatest" % "2.1.2" % "test",
+      libraryDependencies += "org.scalatest" %% "scalatest" % "2.1.3" % "test",
       libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.11.3" % "test",
+      libraryDependencies := {
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          // if scala 2.11+ is used, quasiquotes are merged into scala-reflect
+          case Some((2, scalaMajor)) if scalaMajor >= 11 =>
+            libraryDependencies.value ++ Seq(
+              "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.1")
+          // in Scala 2.10, quasiquotes are provided by macro-paradise
+          case Some((2, 10)) =>
+            libraryDependencies.value ++ Seq(
+              compilerPlugin("org.scalamacros" % "paradise" % "2.0.0-M8" cross CrossVersion.full),
+              "org.scalamacros" %% "quasiquotes" % "2.0.0-M8")
+        }
+      },
       conflictWarning in ThisBuild := ConflictWarning.disable,
       parallelExecution in Test := false, // hello, reflection sync!!
       run <<= run in Compile in sandbox, // http://www.scala-sbt.org/release/docs/Detailed-Topics/Tasks
@@ -191,7 +203,7 @@ object MyBuild extends Build {
     settings = buildSettings ++ Seq(
       sourceDirectory in Compile <<= baseDirectory(root => root),
       sourceDirectory in Test <<= baseDirectory(root => root),
-      libraryDependencies += "org.scalatest" %% "scalatest" % "2.1.2",
+      libraryDependencies += "org.scalatest" %% "scalatest" % "2.1.3",
       parallelExecution in Test := false,
       // scalacOptions ++= Seq()
       // scalacOptions ++= Seq("-Xlog-implicits")