Applier and Unapplier typeclasses

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/misc/ApplierUnapplier.scala

@@ -0,0 +1,33 @@
+package com.avsystem.commons
+package misc
+
+/**
+  * Typeclass which captures case class `apply` method in a raw form that takes untyped sequence of arguments.
+  */
+trait Applier[T] {
+  def apply(rawValues: Seq[Any]): T
+}
+object Applier {
+  implicit def materialize[T]: Applier[T] = macro macros.misc.MiscMacros.applier[T]
+}
+
+/**
+  * Typeclass which captures case class `unapply`/`unapplySeq` method in a raw form that returns
+  * untyped sequence of values.
+  */
+trait Unapplier[T] {
+  def unapply(value: T): Seq[Any]
+}
+object Unapplier {
+  implicit def materialize[T]: Unapplier[T] = macro macros.misc.MiscMacros.unapplier[T]
+}
+
+class ProductUnapplier[T <: Product] extends Unapplier[T] {
+  def unapply(value: T): Seq[Any] = value.productIterator.toArray[Any]
+}
+abstract class ProductApplierUnapplier[T <: Product] extends ProductUnapplier[T] with ApplierUnapplier[T]
+
+trait ApplierUnapplier[T] extends Applier[T] with Unapplier[T]
+object ApplierUnapplier {
+  implicit def materialize[T]: ApplierUnapplier[T] = macro macros.misc.MiscMacros.applierUnapplier[T]
+}

commons-core/src/test/scala/com/avsystem/commons/misc/ApplierUnapplierTest.scala

@@ -0,0 +1,62 @@
+package com.avsystem.commons
+package misc
+
+import org.scalactic.source.Position
+import org.scalatest.FunSuite
+
+case class Empty()
+case class Single(str: String)
+case class Multiple(str: String, int: Int)
+case class Varargs(str: String, ints: Int*)
+case class Generic[T](str: String, value: T)
+
+case class Over22(
+  p01: String = "01", p02: String = "02", p03: String = "03", p04: String = "04", p05: String = "05",
+  p06: String = "06", p07: String = "07", p08: String = "08", p09: String = "09", p10: String = "10",
+  p11: String = "11", p12: String = "12", p13: String = "13", p14: String = "13", p15: String = "15",
+  p16: String = "16", p17: String = "17", p18: String = "18", p19: String = "18", p20: String = "18",
+  p21: String = "21", p22: String = "22", p23: String = "23", p24: String = "24", p25: String = "25"
+)
+
+class Custom(val str: String, val i: Int) {
+  override def hashCode(): Int = (str, i).hashCode()
+  override def equals(obj: Any): Boolean = obj match {
+    case c: Custom => str == c.str && i == c.i
+    case _ => false
+  }
+}
+object Custom {
+  def apply(str: String, i: Int): Custom = new Custom(str, i)
+  def unapply(custom: Custom): Opt[(String, Int)] = Opt((custom.str, custom.i))
+}
+
+class ApplierUnapplierTest extends FunSuite {
+  def roundtrip[T](value: T)(implicit
+    applier: Applier[T], unapplier: Unapplier[T], applierUnapplier: ApplierUnapplier[T], pos: Position
+  ): Unit = {
+    assert(value == applier(unapplier.unapply(value)))
+    assert(value == applierUnapplier(applierUnapplier.unapply(value)))
+  }
+
+  test("no params") {
+    roundtrip(Empty())
+  }
+  test("single param") {
+    roundtrip(Single(""))
+  }
+  test("multiple params") {
+    roundtrip(Multiple("", 42))
+  }
+  test("varargs") {
+    roundtrip(Varargs("", 1, 2, 3))
+  }
+  test("generic") {
+    roundtrip(Generic("a", "b"))
+  }
+  test("more than 22 params") {
+    roundtrip(Over22())
+  }
+  test("custom") {
+    roundtrip(Custom("", 42))
+  }
+}

commons-macros/src/main/scala/com/avsystem/commons/macros/MacroCommons.scala

@@ -49,13 +49,14 @@ trait MacroCommons { bundle =>
   final val NotInheritedFromSealedTypes = getType(tq"$CommonsPkg.annotation.NotInheritedFromSealedTypes")
   final val SeqCompanionSym = typeOf[scala.collection.Seq.type].termSymbol
   final val PositionedAT = getType(tq"$CommonsPkg.annotation.positioned")
-  final val AnnotationType = getType(tq"$ScalaPkg.annotation.Annotation")
   final val ImplicitNotFoundAT = getType(tq"$ScalaPkg.annotation.implicitNotFound")
 
   final val NothingTpe: Type = typeOf[Nothing]
   final val StringPFTpe: Type = typeOf[PartialFunction[String, Any]]
   final val BIterableTpe: Type = typeOf[Iterable[Any]]
   final val BIndexedSeqTpe: Type = typeOf[IndexedSeq[Any]]
+  final val ProductTpe: Type = typeOf[Product]
+  final val AnnotationTpe: Type = typeOf[scala.annotation.Annotation]
 
   final val PartialFunctionClass: Symbol = StringPFTpe.typeSymbol
   final val BIterableClass: Symbol = BIterableTpe.typeSymbol
@@ -801,7 +802,9 @@ trait MacroCommons { bundle =>
     * @param unapply companion object'a unapply method or `NoSymbol` for case class with more than 22 fields
     * @param params  parameters with trees evaluating to default values (or `EmptyTree`s)
     */
-  case class ApplyUnapply(apply: Symbol, unapply: Symbol, params: List[(TermSymbol, Tree)])
+  case class ApplyUnapply(apply: Symbol, unapply: Symbol, params: List[(TermSymbol, Tree)]) {
+    def standardCaseClass: Boolean = apply.isConstructor
+  }
 
   def applyUnapplyFor(tpe: Type): Option[ApplyUnapply] =
     typedCompanionOf(tpe).flatMap(comp => applyUnapplyFor(tpe, comp))
@@ -847,7 +850,8 @@ trait MacroCommons { bundle =>
       val applicableResults = applyUnapplyPairs.flatMap {
         case (apply, unapply) if typeParamsMatch(apply, unapply) =>
           val constructor =
-            if (caseClass && apply.isSynthetic) primaryConstructorOf(dtpe)
+            if (caseClass && apply.isSynthetic && unapply.isSynthetic)
+              primaryConstructorOf(dtpe)
             else NoSymbol
 
           val applySig =

commons-macros/src/main/scala/com/avsystem/commons/macros/misc/MiscMacros.scala

@@ -346,6 +346,87 @@ class MiscMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
 
   def posPoint: Tree =
     q"${c.enclosingPosition.point}"
+
+  def applyUnapplyOrFail(tpe: Type): ApplyUnapply =
+    applyUnapplyFor(tpe).getOrElse(abort(
+      s"$tpe is not a case class or case-class like type: no matching apply/unapply pair found"))
+
+  def applyBody(rawValuesName: TermName, tpe: Type, au: ApplyUnapply): Tree = {
+    val args = au.params.zipWithIndex.map { case ((param, _), idx) =>
+      val res = q"$rawValuesName($idx).asInstanceOf[${actualParamType(param.typeSignature)}]"
+      if (isRepeated(param)) q"$res: _*" else res
+    }
+    if (au.standardCaseClass) q"new $tpe(..$args)"
+    else q"${replaceCompanion(typedCompanionOf(tpe).getOrElse(EmptyTree))}.apply[..${tpe.typeArgs}](..$args)"
+  }
+
+  def unapplyBody(valueName: TermName, tpe: Type, au: ApplyUnapply): Tree = {
+    if (au.standardCaseClass) q"$ScalaPkg.Array(..${au.params.map { case (param, _) => q"$valueName.$param" }})"
+    else {
+      val safeCompanion = replaceCompanion(typedCompanionOf(tpe).getOrElse(EmptyTree))
+      val unapplyRes = q"$safeCompanion.${au.unapply}[..${tpe.typeArgs}]($valueName)"
+      au.params match {
+        case Nil => q"$ScalaPkg.Seq.empty[$ScalaPkg.Any]"
+        case List(_) => q"$ScalaPkg.Array($unapplyRes.get)"
+        case _ =>
+          val resName = c.freshName(TermName("res"))
+          val elems = au.params.indices.map(i => q"$resName.${TermName(s"_${i + 1}")}")
+          q"""
+             val $resName = $unapplyRes.get
+             $ScalaPkg.Array[$ScalaPkg.Any](..$elems)
+           """
+      }
+    }
+  }
+
+  def applier[T: WeakTypeTag]: Tree = {
+    val tpe = weakTypeOf[T].dealias
+    val rawValuesName = c.freshName(TermName("rawValues"))
+    q"""
+      new $CommonsPkg.misc.Applier[$tpe] {
+        def apply($rawValuesName: $ScalaPkg.Seq[$ScalaPkg.Any]): $tpe =
+          ${applyBody(rawValuesName, tpe, applyUnapplyOrFail(tpe))}
+      }
+    """
+  }
+
+  def unapplier[T: WeakTypeTag]: Tree = {
+    val tpe = weakTypeOf[T].dealias
+    val valueName = c.freshName(TermName("value"))
+    val au = applyUnapplyOrFail(tpe)
+    if (au.standardCaseClass && tpe <:< ProductTpe)
+      q"new $CommonsPkg.misc.ProductUnapplier[$tpe]"
+    else
+      q"""
+        new $CommonsPkg.misc.Unapplier[$tpe] {
+          def unapply($valueName: $tpe): $ScalaPkg.Seq[$ScalaPkg.Any] =
+            ${unapplyBody(valueName, tpe, au)}
+        }
+      """
+  }
+
+  def applierUnapplier[T: WeakTypeTag]: Tree = {
+    val tpe = weakTypeOf[T].dealias
+    val rawValuesName = c.freshName(TermName("rawValues"))
+    val valueName = c.freshName(TermName("value"))
+    val au = applyUnapplyOrFail(tpe)
+    if (au.standardCaseClass && tpe <:< ProductTpe)
+      q"""
+        new $CommonsPkg.misc.ProductApplierUnapplier[$tpe] {
+          def apply($rawValuesName: $ScalaPkg.Seq[$ScalaPkg.Any]): $tpe =
+            ${applyBody(rawValuesName, tpe, au)}
+        }
+       """
+    else
+      q"""
+        new $CommonsPkg.misc.ApplierUnapplier[$tpe] {
+          def apply($rawValuesName: $ScalaPkg.Seq[$ScalaPkg.Any]): $tpe =
+            ${applyBody(rawValuesName, tpe, au)}
+          def unapply($valueName: $tpe): $ScalaPkg.Seq[$ScalaPkg.Any] =
+            ${unapplyBody(valueName, tpe, au)}
+        }
+      """
+  }
 }
 
 class WhiteMiscMacros(ctx: whitebox.Context) extends AbstractMacroCommons(ctx) {
@@ -392,7 +473,7 @@ class WhiteMiscMacros(ctx: whitebox.Context) extends AbstractMacroCommons(ctx) {
       case DefaultValueMethod(p) => p
       case p => p
     }
-    if (param.owner.owner.asType.toType <:< AnnotationType && findAnnotation(param, InferAT).nonEmpty)
+    if (param.owner.owner.asType.toType <:< AnnotationTpe && findAnnotation(param, InferAT).nonEmpty)
       q"""throw new $ScalaPkg.NotImplementedError("infer.value")"""
     else
       abort(s"infer.value can be only used as default value of @infer annotation parameters")