Get Name of Reified Function Using Scala Macros

Question

I would like to pattern match certain function and other variable references inside a macro traversing over a Tree. Currently, I am matching based on symbol.fullname like this:

tree match {
  case "$f($x)" if f.symbol != null
  && f.symbol.fullName == "_root_.mypackage.MyClass.myfunc" =>
    ...
  case "$f($x)" if f.symbol != null
  && f.symbol.fullName == "_root_.mypackage.MyClass2.myfunc2" =>
    ...

  case ...
}

However, I would like to additionally check during compilation of this macro that those functions actually exists, e.g. instead of having String, I would like to directly use references, such that the IDE can tell me whether I had a typo in the 'myfunc' name. I was thinking of using using reify, but I am not sure whether that works.

Now lets assume i was looking for println instead of MyClass.myfunc. The first problem I encountered is that you cannot reify(println) or any other function reference directly, because in Scala there are no function references, so you have to write reify(println _) or more specificly in this case reify(println (_: String)) to select what println function we want to call. With the following code I collected all symbols that are inside the expression, but sadly only Predef (from Predef.println) is found but not println itself:

println(reify( println (_:String) ).tree
       .collect { case x if x.symbol != null => x.symbol.fullName } )
// List(<none>, <none>, <none>, scala.Predef, <none>, <none>, scala.Predef, <none>, <none>, scala.Predef)

Any ideas for getting the name of something in scala (currently using 2.12)?

Dmytro Mitin · Answer 1 · 2019-11-28T22:48:13.620

reify(println) compiles.

How do you imagine symbol of function println (_:String)? Where is this function defined? In Predef two methods are defined:

def println(): Unit
def println(x: Any): Unit

Try

val mirror = scala.reflect.runtime.universe.runtimeMirror(this.getClass.getClassLoader) // at runtime
// val mirror = c.mirror // at compile time

mirror.staticClass("mypackage.MyClass").typeSignature.decl(TermName("myfunc"))
// method myfunc

or

typeOf[MyClass].decl(TermName("myfunc"))
// method myfunc

for MyClass#myfunc

definitions.PredefModule.typeSignature.decl(TermName("println")).alternatives
// List(method println, method println)

for both println

definitions.PredefModule.typeSignature.decl(TermName("println")).alternatives
  .filter(_.asMethod.paramLists.map(_.map(_.typeSignature)) == List(List(definitions.AnyTpe)))
// List(method println)

for println(Any):Unit.

For example

def foo(x: Any): Unit = macro impl

def impl(c: blackbox.Context)(x: c.Tree): c.Tree = {
  import c.universe._

  val printlnSymb = definitions.PredefModule.typeSignature.decl(TermName("println")).alternatives
    .filter(_.asMethod.paramLists.map(_.map(_.typeSignature)) == List(List(definitions.AnyTpe)))
    .head

  x match {
    case q"$f($x)" if f.symbol == printlnSymb =>
      println("test")
  }

  q"()"
}

foo(println(1)) //Warning:scalac: test

reify( println (_:String) ).tree.collect { ... produces only List(<none>, <none>, <none>, scala.Predef, <none>, <none>, scala.Predef, <none>, <none>, scala.Predef) because tree reify( println (_:String) ).tree is not typechecked (for typechecked tree it produces List($anonfun, x$1, java.lang.String, scala.Predef.println, scala.Predef.println, scala.Predef, x$1, java.lang.String)).

So another option is to do c.typecheck

def impl(c: blackbox.Context)(x: c.Tree): c.Tree = {
  import c.universe._

  val printlnSymb = (c.typecheck(q"println(_:Any)", silent = false) match {
    case q"($_) => $p($_)" => p
  }).symbol

//val printlnSymb = (c.typecheck(reify { println(_:Any) }.tree, silent = false) match {
//  case q"($_) => $p($_)" => p
//}).symbol

  x match {
    case q"$f($x)" if f.symbol == printlnSymb =>
      println("test")
  }

  q"()"
}

Thx! Btw, `reify(prinln)` works, but only bc its turned into `reify(println())`, so an invocation and not a reference. Also, the question is aimed at a way where println is not a string / quasiquote (not enclosed by quotation marks), so I am lost why you give lots of examples where println is enclosed by quotation marks... On the other hand you seem to be right that a call to typecheck was missing. I still don't understand why reify returns an untyped tree, as it obviously went through typechecking, how else should 'reify(println).staticType' know the type if not by typechecking? — drcicero, Nov 29 '19 at 12:48
@drcicero I guess there is no principal difference between `reify { ... }.tree` and quasiquote `q"..."`. Both are ways to construct a tree. Just `reify` is "former" way and quasiquote is "latter" way. Both `reify{1 + 1}.tree.tpe` and `q"1 + 1".tpe` are `null`, so both trees are not typechecked https://stackoverflow.com/questions/20936509/scala-macros-what-is-the-difference-between-typed-aka-typechecked-an-untyped — Dmytro Mitin, Nov 29 '19 at 14:26
@drcicero I understood that you were looking for way to compare current symbol with some existing symbol. One way to find existing symbol is with `c.typecheck`, another is using its name (location in package, class...) That were my examples. — Dmytro Mitin, Nov 29 '19 at 14:27
@drcicero "how else should `reify(println).staticType` know the type if not by typechecking?" Obviously if you know the type of a tree this doesn't mean that the tree is typed :) — Dmytro Mitin, Nov 29 '19 at 14:29
My hope is that if I use `reify( printnl )` [sic] then intellij / scalac will tell find the typo printnl/println and put a red swiggle below, already at compile time of the macro! It does not do that when I use `q"printnl"`. That's my principled difference. I just checked and it does find such typos! :) — drcicero, Nov 29 '19 at 16:10

drcicero · Answer 2 · 2019-11-29T13:01:52.153

To get the symbols of a reified expressions, the tree of the expressions needs another explicitly pass through typechecking, so the following code works:

val mySym1 = c.typecheck(reify(mypackage.myfunction1 _).tree) match {
  case q"{(..$_) => $f(..$_)}" => f.symbol
}
val mySym2 = c.typecheck(reify(mypackage.myfunction2 _).tree) match {
  case q"{(..$_) => $f(..$_)}" => f.symbol
}

println(mySym.fullName)
// _root_.mypackage.myfunction1

Then you can match based on the symbol:

tree match {
  case "$f($x)" if f.symbol != null => f.symbol match {
    case x if x == mySym1 => ...
    case x if x == mySym2 => ...
    case ...
  }
  case ...
}

score 0 · Accepted Answer · answered Jan 16 '20 at 16:47

There is actually a function called def symbolOf[X]: TypeSymbol that can be used to get a TypeSymbol from a Type. But this only works for TypeSymbols, not TermSymbols, so we cannot do this on functions.

However, if this is our own function, we can replace the definition from def myfunc(): Int = ... with object myfunc { def apply(): Int = ... }. As each object has its own type (called myfunc.type) we can now do the following

package main
object myfunc  { def apply(): Int = 1 }
object myfunc2 { def apply(): Int = 1 }

...

tree match {
  case "$f.apply($x)" if f.symbol == symbolOf[myfunc.type]  => ...
  case "$f.apply($x)" if f.symbol == symbolOf[myfunc2.type] => ...
  case ...
}

Get Name of Reified Function Using Scala Macros

3 Answers3