MacroInstances no longer requires methods to be parameterless

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/meta/MacroInstances.scala

@@ -11,17 +11,17 @@ package meta
   * macro-materialization of typeclasses aggregated by `Instances` trait.
   *
   * `Instances` is a trait that aggregates multiple macro materialized typeclass instances.
-  * There is no fixed interface for `Instances`, its members are inspected by `MacroInstances.materialize`
-  * macro and implemented automatically. `Instances` trait must have only parameterless abstract methods.
-  * Return type of each method must have a companion object which contains `materialize` macro.
-  * That macro will be used to implement that method.
+  * There is no fixed interface for `Instances`, its abstract methods are inspected by
+  * `MacroInstances.materialize` macro and implemented automatically as `<methodReturnTypeCompanion>.materialize`
+  * Therefore, return type type of each method must have a companion object which contains `materialize` macro.
   *
   * Example of `Instances`: [[com.avsystem.commons.rest.ClientInstances ClientInstances]]
   *
   * The `Implicits` type is typically a trait with a collection of implicit definitions whose companion object
   * implements that trait, e.g. [[com.avsystem.commons.rest.DefaultRestImplicits DefaultRestImplicits]].
   * When the macro implements `apply` method of `MacroInstances` contents of `Implicits` are imported into the
   * body of `apply` and visible further by macros that materialize `InstancesTrait`.
+  * If you don't want to inject additional implicits, declare `Implicits` as `Unit`.
   *
   * If `MacroInstances` is accepted as implicit super constructor parameter of a companion object
   * (which is the typical situation) then `this` reference should be passed as `companion`.

commons-core/src/test/scala/com/avsystem/commons/meta/MacroInstancesTest.scala

@@ -0,0 +1,30 @@
+package com.avsystem.commons
+package meta
+
+import com.avsystem.commons.serialization.GenCodec
+
+case class Dep(int: Int)
+case class Klass[T](value: T)
+
+object DependencyImplicits {
+  implicit val depCodec: GenCodec[Dep] = GenCodec.materialize
+}
+
+trait ComplexInstances[T] {
+  def plainCodec: GenCodec[Klass[Int]]
+  def codecWithGeneric: GenCodec[Klass[T]]
+  def dependencyUsingCodec: GenCodec[Klass[Dep]]
+  def parameterizedCodec[A: GenCodec]: GenCodec[Klass[A]]
+}
+
+abstract class HasComplexInstances[T](
+  implicit macroInstances: MacroInstances[DependencyImplicits.type, ComplexInstances[T]]
+) {
+  val instances: ComplexInstances[T] = macroInstances(DependencyImplicits, this)
+}
+
+object MacroInstancesTest extends HasComplexInstances[String] {
+  def main(args: Array[String]): Unit = {
+    println(instances.parameterizedCodec[Double])
+  }
+}

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

@@ -355,23 +355,22 @@ class MiscMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
     }
 
     val instancesMethods = instancesTpe.members.iterator
-      .filter(m => m.isAbstract && m.isMethod).toList.reverse
+      .filter(m => m.isAbstract && m.isMethod).map(_.asMethod).toList.reverse
 
     def impl(singleMethod: Option[Symbol]): Tree = {
       val impls = instancesMethods.map { m =>
         val sig = m.typeSignatureIn(instancesTpe)
         val resultTpe = sig.finalResultType.dealias
-        if (sig.typeParams.nonEmpty || sig.paramLists.nonEmpty) {
-          abort(s"Problem with $m of $instancesTpe: expected non-generic, parameterless method")
-        }
         val resultCompanion = typedCompanionOf(resultTpe)
           .getOrElse(abort(s"$resultTpe has no companion object with `materialize` macro"))
 
         val body =
           if (singleMethod.exists(_ != m)) q"$PredefObj.???"
           else q"$resultCompanion.materialize"
 
-        q"def ${m.name.toTermName} = $body"
+        val tparamDefs = sig.typeParams.map(typeSymbolToTypeDef(_, forMethod = true))
+        val paramDefs = sig.paramLists.map(_.map(paramSymbolToValDef))
+        q"def ${m.name}[..$tparamDefs](...$paramDefs): ${treeForType(sig.finalResultType)} = $body"
       }
 
       val implicitsName = c.freshName(TermName("implicits"))