From a346b10556f8958834c14588e3443d3922d66f89 Mon Sep 17 00:00:00 2001 From: Kevin Wright Date: Thu, 1 Feb 2018 08:30:38 +0000 Subject: Added annotation capture to params Added test for annotation capture Updated to lamdafied syntax for SAM type construction Minor changes to permit compilation under JDK 9 Added Kevin Wright as a contributor --- core/shared/src/main/scala/interface.scala | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'core/shared/src/main/scala/interface.scala') diff --git a/core/shared/src/main/scala/interface.scala b/core/shared/src/main/scala/interface.scala index 846eee9..427c84c 100644 --- a/core/shared/src/main/scala/interface.scala +++ b/core/shared/src/main/scala/interface.scala @@ -25,6 +25,8 @@ trait Subtype[Typeclass[_], Type] { /** partial function defined the subset of values of `Type` which have the type of this subtype */ def cast: PartialFunction[Type, SType] + + override def toString: String = s"Subtype(${typeName.full})" } /** represents a parameter of a case class @@ -89,6 +91,10 @@ trait Param[Typeclass[_], Type] { * @param param the instance of the case class to be dereferenced * @return the parameter value */ def dereference(param: Type): PType + + def annotations: Seq[Any] + + override def toString: String = s"Param($label)" } /** represents a case class or case object and the context required to construct a new typeclass @@ -110,6 +116,7 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( parametersArray: Array[Param[Typeclass, Type]] ) { + override def toString: String = s"CaseClass(${typeName.full}, ${parameters.mkString(",")})" /** constructs a new instance of the case class type * * This method will be implemented by the Magnolia macro to make it possible to construct @@ -128,7 +135,7 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( /** constructs a new instance of the case class type * - * Like [[construct]] this method is implemented by Magnolia and let's you construct case class + * Like [[construct]] this method is implemented by Magnolia and lets you construct case class * instances generically in user code, without knowing their type concretely. * * `rawConstruct`, however, is more low-level in that it expects you to provide a [[Seq]] @@ -152,7 +159,6 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( * * Instances of `SealedTrait` provide access to all of the component subtypes of the sealed trait * which form a coproduct, and to the fully-qualified name of the sealed trait. - * * @param typeName the name of the sealed trait * @param subtypesArray an array of [[Subtype]] instances for each subtype in the sealed trait * @tparam Typeclass type constructor for the typeclass being derived @@ -160,6 +166,8 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( final class SealedTrait[Typeclass[_], Type](val typeName: TypeName, subtypesArray: Array[Subtype[Typeclass, Type]]) { + override def toString: String = s"SealedTrait($typeName, Array[${subtypes.mkString(",")}])" + /** a sequence of all the subtypes of this sealed trait */ def subtypes: Seq[Subtype[Typeclass, Type]] = subtypesArray -- cgit v1.2.3 From 6660480a75b240b7ac613ed308e5b7f7ddfc6459 Mon Sep 17 00:00:00 2001 From: Kevin Wright Date: Thu, 1 Feb 2018 14:42:05 +0000 Subject: Added top-level annotation capture --- core/shared/src/main/scala/interface.scala | 30 +++++++++++++++++++++++---- core/shared/src/main/scala/magnolia.scala | 33 +++++++++++++++++++++--------- examples/shared/src/main/scala/show.scala | 5 ++++- tests/src/main/scala/tests.scala | 4 ++-- 4 files changed, 55 insertions(+), 17 deletions(-) (limited to 'core/shared/src/main/scala/interface.scala') diff --git a/core/shared/src/main/scala/interface.scala b/core/shared/src/main/scala/interface.scala index 427c84c..97ea5b7 100644 --- a/core/shared/src/main/scala/interface.scala +++ b/core/shared/src/main/scala/interface.scala @@ -92,7 +92,13 @@ trait Param[Typeclass[_], Type] { * @return the parameter value */ def dereference(param: Type): PType - def annotations: Seq[Any] + def annotationsArray: Array[Any] + + /** a sequence of objects representing all of the annotations on the case class + * + * For efficiency, this sequence is implemented by an `Array`, but upcast to a + * [[scala.collection.Seq]] to hide the mutable collection API. */ + final def annotations: Seq[Any] = annotationsArray override def toString: String = s"Param($label)" } @@ -113,7 +119,8 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( val typeName: TypeName, val isObject: Boolean, val isValueClass: Boolean, - parametersArray: Array[Param[Typeclass, Type]] + parametersArray: Array[Param[Typeclass, Type]], + annotationsArray: Array[Any] ) { override def toString: String = s"CaseClass(${typeName.full}, ${parameters.mkString(",")})" @@ -152,6 +159,12 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( * For efficiency, this sequence is implemented by an `Array`, but upcast to a * [[scala.collection.Seq]] to hide the mutable collection API. */ final def parameters: Seq[Param[Typeclass, Type]] = parametersArray + + /** a sequence of objects representing all of the annotations on the case class + * + * For efficiency, this sequence is implemented by an `Array`, but upcast to a + * [[scala.collection.Seq]] to hide the mutable collection API. */ + final def annotations: Seq[Any] = annotationsArray } /** represents a sealed trait and the context required to construct a new typeclass instance @@ -163,8 +176,11 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( * @param subtypesArray an array of [[Subtype]] instances for each subtype in the sealed trait * @tparam Typeclass type constructor for the typeclass being derived * @tparam Type generic type of this parameter */ -final class SealedTrait[Typeclass[_], Type](val typeName: TypeName, - subtypesArray: Array[Subtype[Typeclass, Type]]) { +final class SealedTrait[Typeclass[_], Type]( + val typeName: TypeName, + subtypesArray: Array[Subtype[Typeclass, Type]], + annotationsArray: Array[Any] +) { override def toString: String = s"SealedTrait($typeName, Array[${subtypes.mkString(",")}])" @@ -192,6 +208,12 @@ final class SealedTrait[Typeclass[_], Type](val typeName: TypeName, ) rec(0) } + + /** a sequence of objects representing all of the annotations on the topmost trait + * + * For efficiency, this sequence is implemented by an `Array`, but upcast to a + * [[scala.collection.Seq]] to hide the mutable collection API. */ + final def annotations: Seq[Any] = annotationsArray } /** diff --git a/core/shared/src/main/scala/magnolia.scala b/core/shared/src/main/scala/magnolia.scala index 2e13061..00cf5ec 100644 --- a/core/shared/src/main/scala/magnolia.scala +++ b/core/shared/src/main/scala/magnolia.scala @@ -73,8 +73,6 @@ object Magnolia { val magnoliaPkg = c.mirror.staticPackage("magnolia") val scalaPkg = c.mirror.staticPackage("scala") - val sciPkg = c.mirror.staticPackage("scala.collection.immutable") - val repeatedParamClass = definitions.RepeatedParamClass val scalaSeqType = typeOf[Seq[_]].typeConstructor @@ -163,6 +161,8 @@ object Magnolia { val isCaseObject = classType.exists(_.isModuleClass) val isSealedTrait = classType.exists(_.isSealed) + val classAnnotationTrees = typeSymbol.annotations.map(_.tree) + val primitives = Set(typeOf[Double], typeOf[Float], typeOf[Short], @@ -187,8 +187,13 @@ object Magnolia { val impl = q""" $typeNameDef ${c.prefix}.combine($magnoliaPkg.Magnolia.caseClass[$typeConstructor, $genericType]( - $typeName, true, false, new $scalaPkg.Array(0), _ => ${genericType.typeSymbol.asClass.module}) - ) + $typeName, + true, + false, + new $scalaPkg.Array(0), + $scalaPkg.Array(..$classAnnotationTrees), + _ => ${genericType.typeSymbol.asClass.module} + )) """ Some(impl) } else if (isCaseClass || isValueClass) { @@ -277,7 +282,12 @@ object Magnolia { case (((CaseParam(param, repeated, typeclass, paramType, ref), defaultVal), annList), idx) => q"""$paramsVal($idx) = $magnoliaPkg.Magnolia.param[$typeConstructor, $genericType, $paramType]( - ${param.name.decodedName.toString}, $repeated, $ref, $defaultVal, _.${param.name}, $sciPkg.List(..$annList) + ${param.name.decodedName.toString}, + $repeated, + $ref, + $defaultVal, + _.${param.name}, + $scalaPkg.Array(..$annList) )""" } @@ -294,6 +304,7 @@ object Magnolia { false, $isValueClass, $paramsVal, + $scalaPkg.Array(..$classAnnotationTrees), ($fieldValues: $scalaPkg.Seq[Any]) => { if ($fieldValues.lengthCompare($paramsVal.length) != 0) { val msg = "`" + $typeName.full + "` has " + $paramsVal.length + " fields, not " + $fieldValues.size @@ -355,8 +366,9 @@ object Magnolia { ${c.prefix}.dispatch(new $magnoliaPkg.SealedTrait( $typeName, - $subtypesVal: $scalaPkg.Array[$magnoliaPkg.Subtype[$typeConstructor, $genericType]]) - ): $resultType + $subtypesVal: $scalaPkg.Array[$magnoliaPkg.Subtype[$typeConstructor, $genericType]], + $scalaPkg.Array(..$classAnnotationTrees) + )): $resultType }""") } else None @@ -422,7 +434,7 @@ object Magnolia { typeclassParam: => Tc[P], defaultVal: => Option[P], deref: T => P, - annotationsParam: List[Any] + annotationsArrayParam: Array[Any] ): Param[Tc, T] = new Param[Tc, T] { type PType = P def label: String = name @@ -430,7 +442,7 @@ object Magnolia { def default: Option[PType] = defaultVal def typeclass: Tc[PType] = typeclassParam def dereference(t: T): PType = deref(t) - def annotations: Seq[Any] = annotationsParam + def annotationsArray: Array[Any] = annotationsArrayParam } /** constructs a new [[CaseClass]] instance @@ -441,8 +453,9 @@ object Magnolia { obj: Boolean, valClass: Boolean, params: Array[Param[Tc, T]], + annotations: Array[Any], constructor: Seq[Any] => T): CaseClass[Tc, T] = - new CaseClass[Tc, T](name, obj, valClass, params) { + new CaseClass[Tc, T](name, obj, valClass, params, annotations) { def rawConstruct(fieldValues: Seq[Any]): T = constructor(fieldValues) } } diff --git a/examples/shared/src/main/scala/show.scala b/examples/shared/src/main/scala/show.scala index 74914cb..9afc4c9 100644 --- a/examples/shared/src/main/scala/show.scala +++ b/examples/shared/src/main/scala/show.scala @@ -32,7 +32,10 @@ trait GenericShow[Out] { s"${param.label}$attribStr=${param.typeclass.show(param.dereference(value))}" } - join(ctx.typeName.short, paramStrings) + val anns = ctx.annotations.filterNot(_.isInstanceOf[scala.SerialVersionUID]) + val annotationStr = if (anns.isEmpty) "" else anns.mkString("{", ",", "}") + + join(ctx.typeName.short + annotationStr, paramStrings) } } diff --git a/tests/src/main/scala/tests.scala b/tests/src/main/scala/tests.scala index 0f962d2..9153325 100644 --- a/tests/src/main/scala/tests.scala +++ b/tests/src/main/scala/tests.scala @@ -44,7 +44,7 @@ case object Blue extends Color case class MyAnnotation(order: Int) extends StaticAnnotation -case class Attributed( +@MyAnnotation(0) case class Attributed( @MyAnnotation(1) p1: String, @MyAnnotation(2) p2: Int ) @@ -369,7 +369,7 @@ object Tests extends TestApp { test("capture attributes against params") { Show.gen[Attributed].show(Attributed("xyz", 100)) - }.assert(_ == "Attributed(p1{MyAnnotation(1)}=xyz,p2{MyAnnotation(2)}=100)") + }.assert(_ == "Attributed{MyAnnotation(0)}(p1{MyAnnotation(1)}=xyz,p2{MyAnnotation(2)}=100)") } } -- cgit v1.2.3 From c1b9c1f53a6bb3f62abc7141e6b6153d8208e1f0 Mon Sep 17 00:00:00 2001 From: Kevin Wright Date: Thu, 8 Feb 2018 21:20:53 +0000 Subject: post-review changes --- CONTRIBUTORS | 1 + build.sbt | 6 ------ core/shared/src/main/scala/interface.scala | 2 ++ core/shared/src/main/scala/magnolia.scala | 6 ++++-- examples/shared/src/main/scala/decode.scala | 8 ++++---- examples/shared/src/main/scala/show.scala | 2 +- 6 files changed, 12 insertions(+), 13 deletions(-) (limited to 'core/shared/src/main/scala/interface.scala') diff --git a/CONTRIBUTORS b/CONTRIBUTORS index d0d60e5..4e84fbb 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -3,3 +3,4 @@ Loïc Descotte [@loic_d](https://twitter.com/loic_d) Georgi Krastev [@joro_kr](https://twitter.com/joro_kr/) Shadaj Laddad [@shadaj](https://twitter.com/shadajl) Mathias Doenitz [@sirthias](https://twitter.com/sirthias) +Kevin Wright [@thecoda](https://twitter.com/thecoda) diff --git a/build.sbt b/build.sbt index 487c103..50ec53d 100644 --- a/build.sbt +++ b/build.sbt @@ -30,7 +30,6 @@ lazy val tests = project initialCommands in console := """import magnolia.tests._; import magnolia.examples._;""", libraryDependencies ++= Seq( "com.fommil" %% "deriving-macro" % "0.9.0", - "com.fommil" %% "scalaz-deriving" % "0.9.0", // These two to allow compilation under Java 9... // Specifically to import XML stuff that got modularised "javax.xml.bind" % "jaxb-api" % "2.3.0" % "compile", @@ -92,11 +91,6 @@ lazy val publishSettings = Seq( Jon Pretty https://github.com/propensive/magnolia/ - - thecoda - Kevin Wright - https://github.com/kevinwright/ - ) ) diff --git a/core/shared/src/main/scala/interface.scala b/core/shared/src/main/scala/interface.scala index 97ea5b7..1dac65e 100644 --- a/core/shared/src/main/scala/interface.scala +++ b/core/shared/src/main/scala/interface.scala @@ -113,6 +113,7 @@ trait Param[Typeclass[_], Type] { * @param typeName the name of the case class * @param isObject true only if this represents a case object rather than a case class * @param parametersArray an array of [[Param]] values for this case class + * @param annotationsArray an array of instantiated annotations applied to this case class * @tparam Typeclass type constructor for the typeclass being derived * @tparam Type generic type of this parameter */ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( @@ -174,6 +175,7 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] ( * which form a coproduct, and to the fully-qualified name of the sealed trait. * @param typeName the name of the sealed trait * @param subtypesArray an array of [[Subtype]] instances for each subtype in the sealed trait + * @param annotationsArray an array of instantiated annotations applied to this case class * @tparam Typeclass type constructor for the typeclass being derived * @tparam Type generic type of this parameter */ final class SealedTrait[Typeclass[_], Type]( diff --git a/core/shared/src/main/scala/magnolia.scala b/core/shared/src/main/scala/magnolia.scala index 00cf5ec..3cfda3d 100644 --- a/core/shared/src/main/scala/magnolia.scala +++ b/core/shared/src/main/scala/magnolia.scala @@ -202,7 +202,8 @@ object Magnolia { val headParamList = { val primaryConstructor = classType map (_.primaryConstructor) - val optList: Option[List[c.universe.Symbol]] = primaryConstructor flatMap (_.typeSignature.paramLists.headOption) + val optList: Option[List[c.universe.Symbol]] = + primaryConstructor flatMap (_.asMethod.typeSignature.paramLists.headOption) optList.map(_.map(_.asTerm)) } @@ -256,10 +257,11 @@ object Magnolia { val preAssignments = caseParams.map(_.typeclass) - val defaults = headParamList.filterNot(_ => isValueClass) map { plist => + val defaults = headParamList map { plist => // note: This causes the namer/typer to generate the synthetic default methods by forcing // the typeSignature of the "default" factory method to be visited. // It feels like it shouldn't be needed, but we'll get errors otherwise (as discovered after 6 hours debugging) + val companionSym = companionRef.symbol.asModule.info val primaryFactoryMethod = companionSym.decl(TermName("apply")).alternatives.lastOption primaryFactoryMethod.foreach(_.asMethod.typeSignature) diff --git a/examples/shared/src/main/scala/decode.scala b/examples/shared/src/main/scala/decode.scala index 9e91d17..539e478 100644 --- a/examples/shared/src/main/scala/decode.scala +++ b/examples/shared/src/main/scala/decode.scala @@ -10,10 +10,10 @@ trait Decoder[T] { def decode(str: String): T } object Decoder { /** decodes strings */ - implicit val string: Decoder[String] = (str: String) => str + implicit val string: Decoder[String] = (s: String) => s /** decodes ints */ - implicit val int: Decoder[Int] = (str: String) => str.toInt + implicit val int: Decoder[Int] = _.toInt /** binds the Magnolia macro to this derivation object */ implicit def gen[T]: Decoder[T] = macro Magnolia.gen[T] @@ -22,7 +22,7 @@ object Decoder { type Typeclass[T] = Decoder[T] /** defines how new [[Decoder]]s for case classes should be constructed */ - def combine[T](ctx: CaseClass[Decoder, T]): Decoder[T] = (value: String) => { + def combine[T](ctx: CaseClass[Decoder, T]): Decoder[T] = value => { val (_, values) = parse(value) ctx.construct { param => param.typeclass.decode(values(param.label)) @@ -30,7 +30,7 @@ object Decoder { } /** defines how to choose which subtype of the sealed trait to use for decoding */ - def dispatch[T](ctx: SealedTrait[Decoder, T]): Decoder[T] = (param: String) => { + def dispatch[T](ctx: SealedTrait[Decoder, T]): Decoder[T] = param => { val (name, _) = parse(param) val subtype = ctx.subtypes.find(_.typeName.full == name).get subtype.typeclass.decode(param) diff --git a/examples/shared/src/main/scala/show.scala b/examples/shared/src/main/scala/show.scala index 9afc4c9..ecf1dec 100644 --- a/examples/shared/src/main/scala/show.scala +++ b/examples/shared/src/main/scala/show.scala @@ -20,7 +20,7 @@ trait GenericShow[Out] { /** creates a new [[Show]] instance by labelling and joining (with `mkString`) the result of * showing each parameter, and prefixing it with the class name */ - def combine[T](ctx: CaseClass[Typeclass, T]): Show[Out, T] = (value: T) => { + def combine[T](ctx: CaseClass[Typeclass, T]): Show[Out, T] = { value => if (ctx.isValueClass) { val param = ctx.parameters.head param.typeclass.show(param.dereference(value)) -- cgit v1.2.3