Merge pull request #30 from dwickern/qualified-name-of

Add qualifiedNameOf

Author: dwickern

README.md

@@ -72,6 +72,19 @@ println("age")
 println("sayHello")
 ```
 
+Without having an instance of the type for nested case classes:
+```scala mdoc:nest
+case class Pet(age: Int)
+case class Person(name: String, pet: Pet)
+
+println(qualifiedNameOf[Person](_.pet.age))
+```
+```scala mdoc:nest
+// compiles to:
+
+println("pet.age")
+```
+
 You can also use `nameOfType` to get the unqualified name of a type:
 ```scala mdoc:nest
 println(nameOfType[java.lang.String])

src/main/scala-2/com/github/dwickern/macros/NameOf.scala

@@ -27,6 +27,20 @@ trait NameOf {
  */
  def nameOf[T](expr: T => Any): String = macro NameOfImpl.nameOf
 
+ /**
+ * Obtain a fully qualified identifier name as a constant string.
+ *
+ * This overload can be used to access an instance method without having an instance of the type.
+ *
+ * Example usage:
+ * {{{
+ * class Pet(val age: Int)
+ * class Person(val name: String, val pet: Pet)
+ * nameOf[Person](_.pet.age) => "pet.age"
+ * }}}
+ */
+ def qualifiedNameOf[T](expr: T => Any): String = macro NameOfImpl.qualifiedNameOf
+
  /**
  * Obtain a type's unqualified name as a constant string.
  *

src/main/scala-2/com/github/dwickern/macros/NameOfImpl.scala

@@ -47,6 +47,26 @@ object NameOfImpl {
  c.Expr[String](q"$name")
  }
 
+ def qualifiedNameOf(c: whitebox.Context)(expr: c.Expr[Any]): c.Expr[String] = {
+ import c.universe._
+
+ def extract(tree: c.Tree): List[c.Name] = tree match {
+ case Ident(n) => List(n.decodedName)
+ case Select(tree, n) => extract(tree) :+ n.decodedName
+ case Function(_, body) => extract(body)
+ case Block(_, expr) => extract(expr)
+ case Apply(func, _) => extract(func)
+ case TypeApply(func, _) => extract(func)
+ case _ => c.abort(c.enclosingPosition, s"Unsupported expression: ${expr.tree}}")
+ }
+
+ val name = extract(expr.tree)
+ // drop sth like x$1
+ .drop(1)
+ .mkString(".")
+ c.Expr[String](q"$name")
+ }
+
  def nameOfType[T](c: whitebox.Context)(implicit tag: c.WeakTypeTag[T]): c.Expr[String] = {
  import c.universe._
  val name = showRaw(tag.tpe.typeSymbol.name)

src/main/scala-3/com/github/dwickern/macros/NameOf.scala

@@ -27,6 +27,20 @@ trait NameOf {
  */
  transparent inline def nameOf[T](inline expr: T => Any): String = ${NameOfImpl.nameOf('expr)}
 
+ /**
+ * Obtain a fully qualified identifier name as a constant string.
+ *
+ * This overload can be used to access an instance method without having an instance of the type.
+ *
+ * Example usage:
+ * {{{
+ * class Pet(val age: Int)
+ * class Person(val name: String, val pet: Pet)
+ * nameOf[Person](_.pet.age) => "pet.age"
+ * }}}
+ */
+ transparent inline def qualifiedNameOf[T](inline expr: T => Any): String = ${NameOfImpl.qualifiedNameOf('expr)}
+
  /**
  * Obtain a type's unqualified name as a constant string.
  *

src/main/scala-3/com/github/dwickern/macros/NameOfImpl.scala

@@ -9,8 +9,8 @@ object NameOfImpl {
  @tailrec def extract(tree: Tree): String = tree match {
  case Ident(name) => name
  case Select(_, name) => name
- case Block(List(stmt), term) => extract(stmt)
  case DefDef("$anonfun", _, _, Some(term)) => extract(term)
+ case Block(List(stmt), _) => extract(stmt)
  case Block(_, term) => extract(term)
  case Apply(term, _) if term.symbol.fullName != "<special-ops>.throw" => extract(term)
  case TypeApply(term, _) => extract(term)
@@ -22,6 +22,24 @@ object NameOfImpl {
  Expr(name)
  }
 
+ def qualifiedNameOf(expr: Expr[Any])(using Quotes): Expr[String] = {
+ import quotes.reflect.*
+ def extract(tree: Tree): List[String] = tree match {
+ case Ident(name) => List(name)
+ case Select(tree, name) => extract(tree) :+ name
+ case DefDef("$anonfun", _, _, Some(term)) => extract(term)
+ case Block(List(stmt), _) => extract(stmt)
+ case Block(_, term) => extract(term)
+ case Apply(term, _) if term.symbol.fullName != "<special-ops>.throw" => extract(term)
+ case TypeApply(term, _) => extract(term)
+ case Inlined(_, _, term) => extract(term)
+ case Typed(term, _) => extract(term)
+ case _ => throw new MatchError(s"Unsupported expression: ${expr.show}")
+ }
+ val name = extract(expr.asTerm).drop(1).mkString(".")
+ Expr(name)
+ }
+
  def nameOfType[T](using Quotes, Type[T]): Expr[String] = {
  import quotes.reflect.*
  val name = TypeTree.of[T].tpe.dealias match {

src/test/scala/com/github/dwickern/macros/NameOfTest.scala

@@ -74,6 +74,11 @@ class NameOfTest extends AnyFunSuite with Matchers {
  nameOf(generic(???)) should equal ("generic")
  }
 
+ test("identity function") {
+ nameOf[String](x => x) should equal ("x")
+ qualifiedNameOf[String](x => x) should equal ("")
+ }
+
  test("instance member") {
  class SomeClass(val foobar: String)
  val myClass = new SomeClass("")
@@ -92,13 +97,15 @@ class NameOfTest extends AnyFunSuite with Matchers {
  nameOf[SomeClass](_.foobar) should equal ("foobar")
  nameOf { (c: SomeClass) => c.foobar } should equal ("foobar")
  nameOf((_: SomeClass).foobar) should equal ("foobar")
+ qualifiedNameOf[SomeClass](_.foobar) should equal ("foobar")
  }
 
  test("object member") {
  object SomeObject {
  lazy val member = ???
  }
  nameOf(SomeObject.member) should equal ("member")
+ qualifiedNameOf[SomeObject.type](_.member) should equal ("member")
  }
 
  test("class") {
@@ -110,7 +117,52 @@ class NameOfTest extends AnyFunSuite with Matchers {
  nameOf(CaseClass) should equal ("CaseClass")
  nameOfType[CaseClass] should equal ("CaseClass")
  qualifiedNameOfType[CaseClass] should equal ("com.github.dwickern.macros.CaseClass")
+ }
+
+ test("nested case class member") {
+ case class Nested3CaseClass(member: String)
+ case class Nested2CaseClass(nested3CaseClass: Nested3CaseClass)
+ case class Nested1CaseClass(nested2CaseClass: Nested2CaseClass)
+ case class CaseClass(nested1CaseClass: Nested1CaseClass)
+
+ qualifiedNameOf[CaseClass](_.nested1CaseClass.nested2CaseClass.nested3CaseClass.member) should equal("nested1CaseClass.nested2CaseClass.nested3CaseClass.member")
+ qualifiedNameOf((cc: CaseClass) => cc.nested1CaseClass.nested2CaseClass) should equal("nested1CaseClass.nested2CaseClass")
+ }
+
+ test("nested Java method calls") {
+ qualifiedNameOf[String](_.length.toLong) should equal("length.toLong")
+ qualifiedNameOf[String](_.length().toString()) should equal("length.toString")
+ qualifiedNameOf[String] { str => str.length().toString } should equal("length.toString")
+ }
+
+ test("nested symbolic members") {
+ class C1(val `multi word name`: C2)
+ class C2(val 你好: C3)
+ class C3(val ??? : String)
+
+ qualifiedNameOf[C1](_.`multi word name`.你好.???) should equal ("multi word name.你好.???")
+ }
+
+ test("nested generic members") {
+ trait T1 {
+ def foo[T]: T2 = ???
+ }
+ trait T2 {
+ def bar[T]: Int = ???
+ }
+
+ qualifiedNameOf[T1](_.foo.bar) should equal ("foo.bar")
+ }
+
+ test("nested function call") {
+ class C1(val c2: C2)
+ class C2(val c3: C3.type)
+ object C3 {
+ def func(x: Int) = ???
+ }
 
+ qualifiedNameOf[C1](_.c2.c3.func _) should equal ("c2.c3.func")
+ qualifiedNameOf[C1](_.c2.c3.func(???)) should equal ("c2.c3.func")
  }
 
  test("object") {
@@ -189,5 +241,7 @@ class NameOfTest extends AnyFunSuite with Matchers {
  illTyped(""" nameOf(true) """, "Unsupported constant expression: true")
  illTyped(""" nameOf(null) """, "Unsupported constant expression: null")
  illTyped(""" nameOf() """, "Unsupported constant expression: \\(\\)")
+ illTyped(""" qualifiedNameOf[String](_ => ()) """)
+ illTyped(""" qualifiedNameOf[String](_ => 3) """)
  }
 }

src/test/scalajvm/com/github/dwickern/macros/AnnotationTest.scala

@@ -35,6 +35,18 @@ class AnnotationTest extends AnyFunSuite with Matchers {
  annotation.name should === ("classMember")
  }
 
+ test("qualifiedNameOf") {
+ class C(val foo: Foo)
+ class Foo(val bar: Bar)
+ class Bar(val baz: String)
+
+ @Resource(name = qualifiedNameOf[C](_.foo.bar.baz))
+ class AnnotatedClass
+
+ val annotation = classOf[AnnotatedClass].getDeclaredAnnotation(classOf[Resource])
+ annotation.name should === ("foo.bar.baz")
+ }
+
  test("nameOfType") {
  @Resource(name = nameOfType[AnnotatedClass])
  class AnnotatedClass