Added macro for passing all arguments of a method as implicit parameter

Author: beha

README.md

@@ -72,6 +72,8 @@ The kinds of compilation-time data that `sourcecode` provides are:
   you have multiple statements in a `{}` block, `sourcecode.Text` will only 
   capture the source code for the last expression that gets returned. This
   implicit is slightly experimental; be sure to report any bugs you find!
+- `sourcecode.Args`: the arguments that where provided to the nearest enclosing 
+  method
 - `sourcecode.Name.Machine`, `sourcecode.FullName.Machine` and 
   `sourcecode.Enclosing.Machine` which are similar to `sourcecode.Name`,
   `sourcecode.FullName` and `sourcecode.Enclosing` except they do not filter
@@ -475,6 +477,21 @@ be printed. You can, or course, define your own `log` method in the same way,
 customizing it to print or not-print exactly what you want to see via the 
 implicits that `sourcecode` provides!
 
+`sourcecode.Args` can be used to access all parameters that where provided 
+to a method:
+
+```scala
+def debug(implicit name: sourcecode.Name, args: sourcecode.Args): Unit = {
+  println(name.value + args.value.map(_.map(a => a.source + "=" + a.value).mkString("(", ", ", ")")).mkString(""))
+}
+
+def foo(bar: String, baz: Int)(p: Boolean): Unit = {
+  debug
+}
+
+foo("baz", 42)(true) // foo(bar=baz, baz=42)(p=true)
+```
+
 Embedding Domain-Specific Languages
 -----------------------------------
 

sourcecode/shared/src/main/scala/sourcecode/SourceContext.scala

@@ -111,6 +111,24 @@ object Text{
   def apply[T](v: T): Text[T] = macro Impls.text[T]
 
 }
+
+case class Args(value: Seq[Seq[Text[_]]]) extends SourceValue[Seq[Seq[Text[_]]]]
+object Args extends SourceCompanion[Seq[Seq[Text[_]]], Args](new Args(_)) {
+  implicit def generate: Args = macro impl
+  def impl(c: Compat.Context): c.Expr[Args] = {
+    import c.universe._
+
+    def enclosingMethod(owner: Symbol): MethodSymbol =
+      if (owner.isMethod) owner.asMethod else enclosingMethod(owner.owner)
+
+    val method = enclosingMethod(Compat.enclosingOwner(c))
+    val param = method.asMethod.paramLists
+    val texts = param.map(_.map(p => c.Expr[Text[_]](q"""sourcecode.Text($p, ${p.name.toString})""")))
+    val textSeqs = texts.map(s => c.Expr(q"""Seq(..$s)"""))
+    c.Expr[Args](q"""Seq(..$textSeqs)""")
+  }
+}
+
 object Impls{
   def text[T: c.WeakTypeTag](c: Compat.Context)(v: c.Expr[T]): c.Expr[sourcecode.Text[T]] = {
     import c.universe._

sourcecode/shared/src/test/scala/sourcecode/ArgsTests.scala

@@ -0,0 +1,34 @@
+package sourcecode
+
+object ArgsTests {
+  def apply() = {
+    def debug(implicit args: sourcecode.Args): Unit = {
+      assert(args.value.size == 2)
+      assert(args.value(0).size == 3)
+      assert(args.value(0)(0).source == "p1")
+      assert(args.value(0)(0).value == "text")
+      assert(args.value(0)(1).source == "p2")
+      assert(args.value(0)(1).value == 42)
+      assert(args.value(0)(2).source == "p3")
+      assert(args.value(0)(2).value == false)
+      assert(args.value(1)(0).source == "foo")
+      assert(args.value(1)(0).value == "foo")
+      assert(args.value(1)(1).source == "bar")
+      assert(args.value(1)(1).value == "bar")
+    }
+
+    def foo(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String): Unit = {
+      debug
+    }
+
+    def bar(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String): Unit = {
+      val bar = {
+        debug
+        "bar"
+      }
+    }
+
+    foo("text", 42, false)("foo", "bar")
+    bar("text", 42, false)("foo", "bar")
+  }
+}

sourcecode/shared/src/test/scala/sourcecode/Tests.scala

@@ -20,6 +20,7 @@ object Tests{
     Synthetic.run()
     ManualImplicit()
     TextTests()
+    ArgsTests()
 
     println("================LogExample================")
     logExample()