support both scala 2.10 and 2.11

Author: casualjim

.travis.yml

@@ -1,6 +1,7 @@
 language: scala
 scala:
 - 2.11.1
+- 2.10.4
 branches:
   only:
   - master

README.md

@@ -11,7 +11,7 @@ You can find the [documentation on the site](http://muster.json4s.org/docs)
 
 ## Getting the library
 
-This only works with scala 2.11.
+This works with scala 2.10 and up.
 The library is published to maven central so you can get it with:
 
 ```scala

build.sbt

@@ -18,7 +18,7 @@ lazy val argonaut = project in file("codecs/argonaut") dependsOn (core % "compil
 
 lazy val caliperBenchmarks = project in file("benchmarks/caliper") dependsOn (core % "compile->compile;test->test", jackson % "compile->compile;test->test", json4s % "compile->compile;test->test", playJson % "compile->compile;test->test", argonaut % "compile->compile;test->test", jawn % "compile->compile;test->test", strings % "compile->compile;test->test")
 
-scalaVersion in ThisBuild := "2.11.1"
+scalaVersion in ThisBuild := "2.10.4"
 
 crossScalaVersions in ThisBuild := Seq("2.10.4", "2.11.1")
 

core/src/main/scala/muster/helper.scala

@@ -7,7 +7,7 @@ import java.sql.Timestamp
 import scala.annotation.tailrec
 
 /** A utility class for the generator macros */
-class Helper[C <: blackbox.Context](val c: C) {
+class Helper[C <: Context](val c: C) {
   import c.universe._
 
   private val primitiveTypes = Set[Type](c.typeOf[String], c.typeOf[Int], c.typeOf[Long], c.typeOf[Double],
@@ -25,7 +25,7 @@ class Helper[C <: blackbox.Context](val c: C) {
   def isEnum(tpe: c.Type) = tpe <:< c.typeOf[Enumeration#Value]
 
   def caseClassFields(tpe: c.universe.Type): Seq[Symbol] = {
-    tpe.decls.toVector.filter {
+    tpe.declarations.toVector.filter {
       v =>
         if (v.isTerm) {
           val t = v.asTerm
@@ -80,11 +80,11 @@ class Helper[C <: blackbox.Context](val c: C) {
     v.isTerm && v.asTerm.isMethod && v.isPublic &&
       (v.asTerm.asMethod.isSetter || v.asTerm.name.decodedName.toString.startsWith("set")) &&
       varNames.exists(vn => s"set${vn.capitalize}" == methodName || s"${vn}_=" == methodName) &&
-      v.asMethod.paramLists.flatten.length == 1
+      v.asMethod.paramss.flatten.length == 1
   }
 
   def getSetters(tpe: Type): List[Symbol] = {
-    val ctorParams = tpe.member(termNames.CONSTRUCTOR).asTerm.alternatives.map(_.asMethod.paramLists.flatten.map(_.name)).flatten.toSet
+    val ctorParams = tpe.member(nme.CONSTRUCTOR).asTerm.alternatives.map(_.asMethod.paramss.flatten.map(_.name)).flatten.toSet
     val varNames = vars(tpe).filter(sym => sym.asTerm.isProtected || sym.asTerm.isPrivate && !ctorParams(sym.name)).map(_.name.decodedName.toString.trim).toSet
     (tpe.members filter (isJavaOrScalaSetter(varNames, _))).toList
   }
@@ -94,18 +94,18 @@ class Helper[C <: blackbox.Context](val c: C) {
     v.isTerm && v.asTerm.isMethod && v.isPublic &&
       (v.asTerm.asMethod.isGetter || v.asTerm.name.decodedName.toString.startsWith("get")) &&
       varNames.exists(vn => s"get${vn.capitalize}" == methodName || vn == methodName) &&
-      v.asMethod.paramLists.flatten.length == 0
+      v.asMethod.paramss.flatten.length == 0
   }
 
   def getGetters(tpe: Type): List[Symbol] = {
-    val ctorParams = tpe.member(termNames.CONSTRUCTOR).asTerm.alternatives.map(_.asMethod.paramLists.flatten.map(_.name)).flatten.toSet
+    val ctorParams = tpe.member(nme.CONSTRUCTOR).asTerm.alternatives.map(_.asMethod.paramss.flatten.map(_.name)).flatten.toSet
     val valNames = vals(tpe).filterNot(sym => sym.asTerm.isProtected || sym.asTerm.isPrivate ).map(_.name.decodedName.toString.trim).toSet
     val varNames = vars(tpe).filter(sym => sym.asTerm.isProtected || sym.asTerm.isPrivate).map(_.name.decodedName.toString.trim).toSet
     (tpe.members filter (isJavaOrScalaGetter(varNames ++ valNames ++ ctorParams.map(_.decodedName.toString.trim), _))).toList
   }
 
   def enumValues(tpe: Type): List[Symbol] = {
-    tpe.member(TermName("Value")).asTerm.alternatives.headOption.fold(List.empty[Symbol])({ vt =>
+    tpe.member(newTermName("Value")).asTerm.alternatives.headOption.fold(List.empty[Symbol])({ vt =>
       val valueType = vt.asMethod.returnType
       tpe.members.filter(sym => !sym.isMethod && sym.typeSignature.baseType(valueType.typeSymbol) =:= valueType).toList
     })

core/src/main/scala/muster/input/Consumer.scala

@@ -310,7 +310,7 @@ object Consumer {
     */
   implicit def consumer[T]: Consumer[T] = macro consumerImpl[T]
 
-  def consumerImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Consumer[T]] = {
+  def consumerImpl[T: c.WeakTypeTag](c: Context): c.Expr[Consumer[T]] = {
     import c.universe._
 
     val primitiveMap =
@@ -333,7 +333,8 @@ object Consumer {
     val nullNodeDefault = reify(NullNode).tree
 
     def buildValue(_tpe: Type, reader: c.Expr[Any], methodSuffix: String = "", args: List[Tree] = Nil, default: Tree = nullNodeDefault): (Tree, Tree) = {
-      val tpe = _tpe.dealias
+      // TODO: put in separate file for 2.10, 2.11 support, was _tpe.dealias
+      val tpe = _tpe.normalize
       val t = appliedType(weakTypeOf[Consumer[Any]].typeConstructor, tpe :: Nil)
       c.inferImplicitValue(t) match {
         case EmptyTree => c.abort(c.enclosingPosition, s"Couldn't find a muster.input.Consumer[${t.typeSymbol.name.decodedName.toString}], try bringing an implicit value for ${tpe.typeSymbol.name.decodedName.toString} in scope by importing one or defining one.")
@@ -342,17 +343,17 @@ object Consumer {
           val rdrOpt: Tree = {
             if (helper.isPrimitive(tpe)) {
               val nm = primitiveMap(tpe)
-              Apply(Select(reader.tree, TermName(s"read${nm}${methodSuffix}Opt")), args)
+              Apply(Select(reader.tree, newTermName(s"read${nm}${methodSuffix}Opt")), args)
             } else if (helper.isOption(tpe)) {
               val agType = helper.resolveInnerOptionType(tpe)
               val nm = primitiveMap(agType)
-              Apply(Select(reader.tree, TermName(s"read${nm}${methodSuffix}Opt")), args)
+              Apply(Select(reader.tree, newTermName(s"read${nm}${methodSuffix}Opt")), args)
             } else if (helper.isSeq(tpe) || helper.isSet(tpe))
-              Apply(Select(reader.tree, TermName(s"readArray${methodSuffix}Opt")), args)
+              Apply(Select(reader.tree, newTermName(s"readArray${methodSuffix}Opt")), args)
             else if (helper.isEnum(tpe)) {
-              Apply(Select(reader.tree, TermName(s"readString${methodSuffix}Opt")), args)
+              Apply(Select(reader.tree, newTermName(s"readString${methodSuffix}Opt")), args)
             } else
-              Apply(Select(reader.tree, TermName(s"readObject${methodSuffix}Opt")), args)
+              Apply(Select(reader.tree, newTermName(s"readObject${methodSuffix}Opt")), args)
           }
 
           (rdrOpt, resolved)
@@ -362,24 +363,24 @@ object Consumer {
     def setterDef(returnType: Type, reader: c.Expr[Any], fieldName: Tree, defVal: Tree = EmptyTree): Tree = {
       val t = appliedType(weakTypeOf[Consumer[Any]].typeConstructor, returnType :: Nil)
       val (definition, resolved) = buildValue(returnType, reader, "Field", List(fieldName), defVal)
-      val fn = c.freshName("consumer$")
-      val vn = TermName(fn)
+      val fn = c.fresh("consumer$")
+      val vn = newTermName(fn)
       val v = ValDef(Modifiers(), vn, TypeTree(t), resolved)
-      val cn = c.freshName("node$")
+      val cn = c.fresh("node$")
 
       defVal match {
         case EmptyTree =>
-          val noDefault = Apply(Select(definition, TermName("getOrElse")), nullNodeDefault :: Nil)
-          val ce = c.Expr[AstNode[_]](Ident(TermName(cn)))
-          val ct: Tree = ValDef(Modifiers(), TermName(cn), TypeTree(weakTypeOf[AstNode[_]]), noDefault)
-          Block(v :: ct :: Nil, Apply(Select(Ident(vn), TermName("consume")), ce.tree :: Nil))
+          val noDefault = Apply(Select(definition, newTermName("getOrElse")), nullNodeDefault :: Nil)
+          val ce = c.Expr[AstNode[_]](Ident(newTermName(cn)))
+          val ct: Tree = ValDef(Modifiers(), newTermName(cn), TypeTree(weakTypeOf[AstNode[_]]), noDefault)
+          Block(v :: ct :: Nil, Apply(Select(Ident(vn), newTermName("consume")), ce.tree :: Nil))
         case defTree =>
-          val ce = c.Expr[Option[AstNode[_]]](Ident(TermName(cn)))
-          val ct: Tree = ValDef(Modifiers(), TermName(cn), TypeTree(weakTypeOf[Option[AstNode[_]]]), definition)
+          val ce = c.Expr[Option[AstNode[_]]](Ident(newTermName(cn)))
+          val ct: Tree = ValDef(Modifiers(), newTermName(cn), TypeTree(weakTypeOf[Option[AstNode[_]]]), definition)
           //          val cons = Apply(Select(Ident(vn), TermName("consume")), ce.tree :: Nil)
           val res = reify(
             ce.splice match {
-              case Some(n) => c.Expr(Apply(Select(Ident(vn), TermName("consume")), Ident(TermName("n")) :: Nil)).splice
+              case Some(n) => c.Expr(Apply(Select(Ident(vn), newTermName("consume")), Ident(newTermName("n")) :: Nil)).splice
               case _ => c.Expr(defTree).splice
             })
           Block(v :: ct :: Nil, res.tree)
@@ -401,7 +402,7 @@ object Consumer {
               !(sym.isParamWithDefault || sym.typeSignature <:< typeOf[Option[_]])
             }
 
-            val expr = c.Expr[Set[String]](Apply(Select(Ident(TermName("Set")), TermName("apply")),
+            val expr = c.Expr[Set[String]](Apply(Select(Ident(newTermName("Set")), newTermName("apply")),
               ctors.flatten.filter(isRequired).map(sym => Literal(Constant(sym.name.decodedName.toString)))
             ))
 
@@ -416,11 +417,11 @@ object Consumer {
 
 
 
-          val ctors: List[MethodSymbol] = tpe.member(termNames.CONSTRUCTOR)
+          val ctors: List[MethodSymbol] = tpe.member(nme.CONSTRUCTOR)
             .asTerm.alternatives // List of constructors
             .map(_.asMethod) // method symbols
-            .sortBy(-_.paramLists.flatten.size)
-          val ifExprsAndParams = ctors.map(ctor => ctorCheckingExpr(ctor.paramLists)).zip(ctors.map(_.asMethod.paramLists))
+            .sortBy(-_.paramss.flatten.size)
+          val ifExprsAndParams = ctors.map(ctor => ctorCheckingExpr(ctor.paramss)).zip(ctors.map(_.asMethod.paramss))
 
           ifElseTreeBuilder(ifExprsAndParams)
         }
@@ -433,14 +434,14 @@ object Consumer {
               // Change out the types if it has type parameters
               val pTpe = pSym.typeSignature.substituteTypes(sym.asClass.typeParams, tpeArgs)
               val fieldName = Literal(Constant(pSym.name.decodedName.toString))
-              val pTnm = TermName(pSym.name.decodedName.toString)
+              val pTnm = newTermName(pSym.name.decodedName.toString)
 
               // If param has defaults, try to find the val in map, or call
               // default evaluation from its companion object
               // is the sym.companionSymbol.isTerm the best way to check for NoSymbol?
               // is there a way to get teh default values for the overloaded constructors?
-              val tree = if (pSym.asTerm.isParamWithDefault && sym.companion.isTerm) {
-                val defVal = Select(Ident(sym.companion), TermName("$lessinit$greater$default$" + (index + 1).toString))
+              val tree = if (pSym.asTerm.isParamWithDefault && sym.companionSymbol.isTerm) {
+                val defVal = Select(Ident(sym.companionSymbol), newTermName("$lessinit$greater$default$" + (index + 1).toString))
                 //                val defValG = Apply(Select(New(weakTypeOf[ConstantNode[_]])))
                 setterDef(pTpe, reader, fieldName, defVal)
               } else {
@@ -449,13 +450,13 @@ object Consumer {
               (ValDef(Modifiers(), pTnm, TypeTree(pTpe), tree), Ident(pTnm))
           })
 
-          Block(params.flatMap(_.map(_._1)), params.foldLeft(Select(New(Ident(sym)), termNames.CONSTRUCTOR): Tree) { (ct, args) =>
+          Block(params.flatMap(_.map(_._1)), params.foldLeft(Select(New(Ident(sym)), nme.CONSTRUCTOR): Tree) { (ct, args) =>
             Apply(ct, args.map(_._2))
           })
         }
 
-        val on = c.freshName("consumed$")
-        val ot = TermName(on)
+        val on = c.fresh("consumed$")
+        val ot = newTermName(on)
         val otr: Tree = ValDef(Modifiers(), ot, TypeTree(tpe), pickConstructorTree(reify(reader.splice.keySet)))
 
         val setterBlocks: List[Tree] = {
@@ -464,7 +465,7 @@ object Consumer {
             val stripped = pSym.name.decodedName.toString.replaceFirst("^set", "").replaceFirst("_=$", "")
             val name = if (needsLower) stripped(0).toLower + stripped.substring(1) else stripped
             val paramType = {
-              val tp = pSym.asMethod.paramLists.head.head
+              val tp = pSym.asMethod.paramss.head.head
               tp.typeSignatureIn(tpe)
             }
             Apply(Select(Ident(ot), pSym.name), setterDef(paramType, reader, Literal(Constant(name))) :: Nil)
@@ -484,7 +485,7 @@ object Consumer {
       new Consumer[T] {
         def consume(node: AstNode[_]): T = {
           node match {
-            case obj: ObjectNode => c.Expr[T](buildObject(thisType, c.Expr[ObjectNode](Ident(TermName("obj"))))).splice
+            case obj: ObjectNode => c.Expr[T](buildObject(thisType, c.Expr[ObjectNode](Ident(newTermName("obj"))))).splice
             case NullNode | UndefinedNode => null.asInstanceOf[T]
             case x => throw new MappingException(s"Got a ${x.getClass.getSimpleName} and expected an ObjectNode")
           }

core/src/main/scala/muster/output/Producer.scala

@@ -178,23 +178,30 @@ object Producer {
 
   implicit def producer[T]: Producer[T] = macro producerImpl[T]
 
-  def producerImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Producer[T]] = {
+  def producerImpl[T: c.WeakTypeTag](c: Context): c.Expr[Producer[T]] = {
     import c.universe._
     val helper = new Helper[c.type](c)
-    val tpe = weakTypeOf[T].dealias
+    // TODO: put in separate helper for 2.10, 2.11 differences, was weakTypeOf[T].dealias
+    val tpe = weakTypeOf[T].normalize
 
     def buildObject(target: Tree, formatter: Tree): Tree = {
       val TypeRef(_, sym: Symbol, _) = tpe
       val fields = helper.getGetters(tpe)
        val fieldTrees = fields map { fld =>
-        val tt = fld.asMethod.typeSignatureIn(tpe).resultType
+        // TODO: put in separate helper for 2.10, 2.11 differences, was fld.asMethod.typeSignatureIn(tpe).resultType
+        val tt = fld.asMethod.typeSignatureIn(tpe) match {
+          case NullaryMethodType(rtpe) => rtpe
+          case MethodType(_, ret) => ret
+          case PolyType(_, rtpe) => rtpe
+          case rtpe => rtpe
+        }
         val on = fld.name.decodedName.toString.trim
         val needsLower = on.startsWith("get")
         val stripped = on.replaceFirst("^get", "")
         val fieldName = if (needsLower) stripped(0).toLower + stripped.substring(1) else stripped
         val fieldPath = Select(target, fld.asTerm.name)
         // TODO: Add field renaming strategy
-        val startFieldExpr = Apply(Select(formatter, TermName("startField")), Literal(Constant(fieldName)) :: Nil)
+        val startFieldExpr = Apply(Select(formatter, newTermName("startField")), Literal(Constant(fieldName)) :: Nil)
 
         val pTpe = appliedType(weakTypeOf[Producer[Any]], tt::Nil)
         val fVal: List[Tree] = c.inferImplicitValue(pTpe) match {
@@ -203,23 +210,23 @@ object Producer {
             // error returns unit
             c.abort(c.enclosingPosition, s"Couldn't find an implicit $pTpe, try defining one or bringing one into scope")
           case x =>
-            val pn = c.freshName("producer$")
-            val ptn = TermName(pn)
+            val pn = c.fresh("producer$")
+            val ptn = newTermName(pn)
             val pv: Tree = ValDef(Modifiers(), ptn, TypeTree(pTpe), x)
-            val fn = c.freshName("value$")
-            val ftn = TermName(fn)
+            val fn = c.fresh("value$")
+            val ftn = newTermName(fn)
             val fv: Tree = ValDef(Modifiers(), ftn, TypeTree(tt), fieldPath)
-            val write: Tree = Apply(Select(Ident(ptn), TermName("produce")), Ident(ftn) :: formatter :: Nil)
+            val write: Tree = Apply(Select(Ident(ptn), newTermName("produce")), Ident(ftn) :: formatter :: Nil)
             fv :: pv ::  write :: Nil
         }
         startFieldExpr :: fVal
       }
       Block(
         Apply(
-          Select(formatter, TermName("startObject")),
+          Select(formatter, newTermName("startObject")),
           Literal(Constant(sym.name.decodedName.toString))::Nil) ::
         fieldTrees.reverse.flatten,
-        Apply(Select(formatter, TermName("endObject")), Nil))
+        Apply(Select(formatter, newTermName("endObject")), Nil))
 
     }
 
@@ -228,7 +235,7 @@ object Producer {
       reify {
         new Producer[T] {
           def produce(value: T, formatter: OutputFormatter[_]): Unit = {
-            c.Expr(buildObject(Ident(TermName("value")), Ident(TermName("formatter")))).splice
+            c.Expr(buildObject(Ident(newTermName("value")), Ident(newTermName("formatter")))).splice
           }
         }
       }
@@ -276,7 +283,7 @@ object Producer {
   *
   * @tparam T the type of value this producer knows about
   */
-@implicitNotFound("Couldn't find a producer for ${T}. Try importing muster._ or to implement a muster.Consumable")
+@implicitNotFound("Couldn't find a producer for ${T}. Try importing muster._ or to implement a muster.Producer")
 trait Producer[T] {
   def produce(value: T, formatter: OutputFormatter[_])
 }

core/src/main/scala/muster/package.scala

@@ -9,7 +9,7 @@
   *
   * Getting the library
   *
-  * This only works with scala 2.11.
+  * This works with scala 2.10 and up.
   * Check the [[https://github.com/json4s/muster/releases releases page]] for the latest version.
   * The library is published to maven central so you can get it with:
   *