How to distinguish implicit compiler conversion from explicitly called?

Question

Imagine passing these two equivalent expressions to a Scala macro:

• with implicit conversion using compiler: 1+"foo"
• with explicitly called implicit conversion: any2stringadd(1)+"foo"

Is there a way to distinguish between the two inside a macro?

Answer 1

First of all, the case 1 + "foo" will be complicated, because in fact there is no implicit conversion: Int really, really has this + method ( unfortunately ).

So, you're out of luck if this is your use case, but you can do what you describe more generally. In the examples below, I will use the following setting:

 case class Foo(i: Int) case class Bar(s: String) implicit def foo2bar(foo: Foo) = Bar(foo.i.toString) 

First for an elegant approach:

 object ConversionDetector { import scala.language.experimental.macros import scala.reflect.macros.Context def sniff[A](tree: _): Boolean = macro sniff_impl[A] def sniff_impl[A: c.WeakTypeTag](c: Context)(tree: c.Tree) = { // First we confirm that the code typechecks at all: c.typeCheck(tree, c.universe.weakTypeOf[A]) // Now we try it without views: c.literal( c.typeCheck(tree, c.universe.weakTypeOf[A], true, true, false).isEmpty ) } } 

Works as desired:

 scala> ConversionDetector.sniff[Bar](Foo(42)) res1: Boolean = true scala> ConversionDetector.sniff[Bar](foo2bar(Foo(42))) res2: Boolean = false 

Unfortunately, this requires untyped macros, which are currently only available in Macro Paradise .

You can get what you want with the old old def macros in 2.10, but this is a bit of a hack:

 object ConversionDetector { import scala.language.experimental.macros import scala.reflect.macros.Context def sniff[A](a: A) = macro sniff_impl[A] def sniff_impl[A: c.WeakTypeTag](c: Context)(a: c.Expr[A]) = { import c.universe._ c.literal( a.tree.exists { case app @ Apply(fun, _) => app.pos.column == fun.pos.column case _ => false } ) } } 

And again:

 scala> ConversionDetector.sniff[Bar](Foo(42)) res1: Boolean = true scala> ConversionDetector.sniff[Bar](foo2bar(Foo(42))) res2: Boolean = false 

The trick is to look for places where we see the functional application in our abstract syntax tree, and then check if the positions of the child node Apply node and its fun the same column, which indicates that the method call is clearly not present in the source.

Answer 2

This is a hack, but it can help you:

 import scala.reflect.macros.Context import language.experimental.macros object Macros { def impl(c: Context)(x: c.Expr[Int]) = { import c.universe._ val hasInferredImplicitArgs = x.tree.isInstanceOf[scala.reflect.internal.Trees#ApplyToImplicitArgs] val isAnImplicitConversion = x.tree.isInstanceOf[scala.reflect.internal.Trees#ApplyImplicitView] println(s"x = ${x.tree}, args = $hasInferredImplicitArgs, view = $isAnImplicitConversion") c.literalUnit } def foo(x: Int) = macro impl } import language.implicitConversions import scala.reflect.ClassTag object Test extends App { def bar[T: ClassTag](x: T) = x implicit def foo(x: String): Int = augmentString(x).toInt Macros.foo(2) Macros.foo(bar(2)) Macros.foo("2") } 08:30 ~/Projects/210x/sandbox (2.10.x)$ ss x = 2, args = false, view = false x = Test.this.bar[Int](2)(ClassTag.Int), args = true, view = false x = Test.this.foo("2"), args = false, view = true