- Fixed evaluation of arguments passed to the primary constructor with Scala 2.11

- Workaround for evaluation of arguments passed to the primary constructor with Scala 2.10
- Added test for implicit parameter lists
- Added test for empty parameter lists

Author: beha

README.md

@@ -492,6 +492,23 @@ def foo(bar: String, baz: Int)(p: Boolean): Unit = {
 foo("baz", 42)(true) // foo(bar=baz, baz=42)(p=true)
 ```
 
+Please note, that it's currently not possible to access the arguments passed
+to a constructor if you are using Scala 2.10, e.g. the following code will 
+work as expected with 2.11, but _not_ with 2.10:
+```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(""))
+}
+
+class Foo(arg1: String, arg2: Int) {
+  debug
+}
+
+new Foo("bar", 42)
+```
+
+For 2.10 `sourcecode.Args.value will be an empty list.`
+
 Embedding Domain-Specific Languages
 -----------------------------------
 

build.sbt

@@ -22,6 +22,10 @@ lazy val sourcecode = crossProject.settings(
     if (scalaVersion.value startsWith "2.10.") Seq(baseDirectory.value / ".."/"shared"/"src"/ "main" / "scala-2.10")
     else Seq(baseDirectory.value / ".."/"shared" / "src" / "main" / "scala-2.11")
   },
+  unmanagedSourceDirectories in Test ++= {
+    if (scalaVersion.value startsWith "2.10.") Seq(baseDirectory.value / ".."/"shared"/"src"/ "test" / "scala-2.10")
+    else Seq(baseDirectory.value / ".."/"shared" / "src" / "test" / "scala-2.11")
+  },
   publishTo := Some("releases"  at "https://oss.sonatype.org/service/local/staging/deploy/maven2"),
 
   pomExtra :=

sourcecode/shared/src/main/scala-2.10/sourcecode/Compat.scala

@@ -9,4 +9,12 @@ object Compat{
       .owner
       .asInstanceOf[c.Symbol]
   }
+
+  def enclosingParamList(c: Context): List[List[c.Symbol]] = {
+    def nearestClassOrMethod(owner: c.Symbol): c.Symbol =
+      if (owner.isMethod || owner.isClass) owner else nearestClassOrMethod(owner.owner)
+
+    val com = nearestClassOrMethod(enclosingOwner(c))
+    if (com.isClass) List() else com.asMethod.paramss
+  }
 }

sourcecode/shared/src/main/scala-2.11/sourcecode/Compat.scala

@@ -3,4 +3,13 @@ package sourcecode
 object Compat{
   type Context = scala.reflect.macros.blackbox.Context
   def enclosingOwner(c: Context) = c.internal.enclosingOwner
+
+  def enclosingParamList(c: Context): List[List[c.Symbol]] = {
+    def nearestEnclosingMethod(owner: c.Symbol): c.Symbol =
+      if (owner.isMethod) owner
+      else if (owner.isClass) owner.asClass.primaryConstructor
+      else nearestEnclosingMethod(owner.owner)
+
+    nearestEnclosingMethod(enclosingOwner(c)).asMethod.paramLists
+  }
 }

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

@@ -117,12 +117,7 @@ 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.paramss
+    val param = Compat.enclosingParamList(c)
     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)""")

sourcecode/shared/src/test/scala-2.10/sourcecode/ArgsPrimaryConstructorTests.scala

@@ -0,0 +1,17 @@
+package sourcecode
+
+object ArgsPrimaryConstructorTests {
+  def apply() = {
+
+    var args: Seq[Seq[(String, Any)]] = Seq()
+
+    def debug(implicit arguments: sourcecode.Args): Unit = args = arguments.value.map(_.map(t => t.source -> t.value))
+
+    class Foo(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String) {
+      debug
+    }
+
+    new Foo("text", 42, false)("foo", "bar")
+    assert(args == Seq())
+  }
+}

sourcecode/shared/src/test/scala-2.11/sourcecode/ArgsPrimaryConstructorTests.scala

@@ -0,0 +1,17 @@
+package sourcecode
+
+object ArgsPrimaryConstructorTests {
+  def apply() = {
+
+    var args: Seq[Seq[(String, Any)]] = Seq()
+
+    def debug(implicit arguments: sourcecode.Args): Unit = args = arguments.value.map(_.map(t => t.source -> t.value))
+
+    class Foo(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String) {
+      debug
+    }
+
+    new Foo("text", 42, false)("foo", "bar")
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42, "p3" -> false), Seq("foo" -> "foo", "bar" -> "bar")))
+  }
+}

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

@@ -3,21 +3,9 @@ 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).size == 2)
-      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")
-    }
+    var args: Seq[Seq[(String, Any)]] = Seq()
+
+    def debug(implicit arguments: sourcecode.Args): Unit = args = arguments.value.map(_.map(t => t.source -> t.value))
 
     def foo(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String): Unit = {
       debug
@@ -30,7 +18,39 @@ object ArgsTests {
       }
     }
 
+    def baz: Unit = {
+      debug
+    }
+
+    def withImplicit(p1: String, p2: Long, p3: Boolean)(implicit foo: String): Unit = {
+      debug
+    }
+
+    class Foo(p1: String, p2: Long, p3: Boolean)(foo: String, bar: String) {
+
+      def this(p1: String, p2: Long) = {
+        this(p1, p2, false)("foo", "bar")
+        debug
+      }
+    }
+
+    new Foo("text", 42)
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42)))
+
     foo("text", 42, false)("foo", "bar")
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42, "p3" -> false), Seq("foo" -> "foo", "bar" -> "bar")))
+
     bar("text", 42, false)("foo", "bar")
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42, "p3" -> false), Seq("foo" -> "foo", "bar" -> "bar")))
+
+    baz
+    assert(args == Seq())
+
+    withImplicit("text", 42, false)("foo")
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42, "p3" -> false), Seq("foo" -> "foo")))
+
+    implicit val implicitFoo = "bar"
+    withImplicit("text", 42, false)
+    assert(args == Seq(Seq("p1" -> "text", "p2" -> 42, "p3" -> false), Seq("foo" -> "bar")))
   }
 }

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

@@ -21,6 +21,7 @@ object Tests{
     ManualImplicit()
     TextTests()
     ArgsTests()
+    ArgsPrimaryConstructorTests()
 
     println("================LogExample================")
     logExample()