Support for multiple parameter lists

Author: MateuszKubuszok

pulp/src/main/scala/io/scalaland/pulp/internals/WiredImpl.scala

@@ -8,30 +8,30 @@ private[pulp] class WiredImpl(wiredType: WiredImpl.Type)(val c: Context)(annotte
   import c.universe._
 
   private def buildProviderMethod(classDef: ClassDef): ValOrDefDef = classDef match {
-    case q"""$_ class $name[..${params: Seq[TypeDef]}] $_(..${ctorParams: Seq[ValDef]})
+    case q"""$_ class $name[..${params: Seq[TypeDef]}] $_(...${ctorParams: Seq[Seq[ValDef]]})
                   extends { ..$_ }
                   with ..$_ { $_ => ..$_ }""" =>
-      val providerArgs = ctorParams.map(p => q"${p.name}: io.scalaland.pulp.Provider[${p.tpt}]")
+      val providerArgs = ctorParams.flatten.map(p => q"${p.name}: io.scalaland.pulp.Provider[${p.tpt}]")
       val ctorArgs =
-        if (wiredType != WiredImpl.Type.Singleton) ctorParams.map(p => q"${p.name}.get")
-        else ctorParams.map(p => q"io.scalaland.pulp.Provider.get[${p.tpt}]")
+        if (wiredType != WiredImpl.Type.Singleton) ctorParams.map(_.map(p => q"${p.name}.get"))
+        else ctorParams.map(_.map(p => q"io.scalaland.pulp.Provider.get[${p.tpt}]"))
 
       withTraceLog("Provider implicit expanded") {
         wiredType match {
           case WiredImpl.Type.Default =>
             q"""implicit def implicitProvider[..$params](implicit ..$providerArgs)
                   : io.scalaland.pulp.Provider[$name[..${params.map(_.name)}]] =
-                io.scalaland.pulp.Provider.const(new $name[..${params.map(_.name)}](..$ctorArgs))""": DefDef
+                io.scalaland.pulp.Provider.const(new $name[..${params.map(_.name)}](...$ctorArgs))""": DefDef
 
           case WiredImpl.Type.Factory =>
             q"""implicit def implicitProvider[..$params](implicit ..$providerArgs)
                   : io.scalaland.pulp.Provider[$name[..${params.map(_.name)}]] =
-                io.scalaland.pulp.Provider.factory(new $name[..${params.map(_.name)}](..$ctorArgs))""": DefDef
+                io.scalaland.pulp.Provider.factory(new $name[..${params.map(_.name)}](...$ctorArgs))""": DefDef
 
           case WiredImpl.Type.Singleton if params.isEmpty =>
             q"""implicit lazy val implicitProvider
                   : io.scalaland.pulp.Provider[$name[..${params.map(_.name)}]] =
-                io.scalaland.pulp.Provider.const(new $name[..${params.map(_.name)}](..$ctorArgs))""": ValDef
+                io.scalaland.pulp.Provider.const(new $name[..${params.map(_.name)}](...$ctorArgs))""": ValDef
 
           case WiredImpl.Type.Singleton if params.nonEmpty =>
             c.abort(c.enclosingPosition, "@Singleton cannot be used on parametric types")

pulp/src/test/scala/io/scalaland/pulp/FactorySpec.scala

@@ -64,4 +64,17 @@ class FactorySpec extends FlatSpec {
     // then
     assertCompiles("Provider.get[ComplexCase[Double]]")
   }
+
+  it should "generate implicit Provider def for a class with multiple parameter lists" in {
+    // given
+    implicit val stringProvider: Provider[String] = Provider.const("test")
+    implicit val intProvider: Provider[Int] = Provider.const(10)
+    implicit val doubleProvider: Provider[Double] = Provider.const(20.4)
+
+    // when
+    @Factory class ComplexCase[T](t: T)(name: String)(size: Int)
+
+    // then
+    assertCompiles("Provider.get[ComplexCase[Double]]")
+  }
 }

pulp/src/test/scala/io/scalaland/pulp/SingletonSpec.scala

@@ -28,4 +28,16 @@ class SingletonSpec extends FlatSpec {
     assertCompiles("Provider.get[MonoCompanion]")
     assertCompiles("Provider.get[MonoCompanion2]")
   }
+
+  it should "generate implicit Provider def for a class with multiple parameter lists" in {
+    // given
+    implicit val stringProvider: Provider[String] = Provider.const("test")
+    implicit val intProvider: Provider[Int] = Provider.const(10)
+
+    // when
+    @Singleton class ComplexCase(name: String)(size: Int)
+
+    // then
+    assertCompiles("Provider.get[ComplexCase]")
+  }
 }

pulp/src/test/scala/io/scalaland/pulp/WiredSpec.scala

@@ -64,4 +64,17 @@ class WiredSpec extends FlatSpec {
     // then
     assertCompiles("Provider.get[ComplexCase[Double]]")
   }
+
+  it should "generate implicit Provider def for a class with multiple parameter lists" in {
+    // given
+    implicit val stringProvider: Provider[String] = Provider.const("test")
+    implicit val intProvider: Provider[Int] = Provider.const(10)
+    implicit val doubleProvider: Provider[Double] = Provider.const(20.4)
+
+    // when
+    @Wired class ComplexCase[T](t: T)(name: String)(size: Int)
+
+    // then
+    assertCompiles("Provider.get[ComplexCase[Double]]")
+  }
 }