Override method from macro - scala

Question

Is it possible to add method definition from macro call? Here is an example:
object Macros { def someMacro = ...}
trait Foo { def foo:Int }
class Bar extends Foo { someMacro() }
//calls to (new Bar).foo is possible and return value defined in someMacro

Answer 1

This is indeed possible with Scala macro annotations. One thing that macro annotations enable is adding members to class definitions. Since macros are compiled before other steps of type checking, you can use this functionality to satisfy a trait's constraints.
For example, the following macro annotation #foo adds a foo method to its annotated classes. Here, the method takes no arguments and returns an Int:
object Macros {
def fooImpl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
import c.universe._
val fooMethod = DefDef(NoMods, newTermName("foo"), List(), List(List()), TypeTree(), Literal(Constant(5)))
c.Expr[Any](annottees.map(_.tree).toList match {
case List(ClassDef(mods, name, tdefs, Template(parents, self, body))) =>
ClassDef(mods, name, tdefs, Template(parents, self, body :+ fooMethod))
})
}
}
class foo extends StaticAnnotation {
def macroTransform(annottees: Any*) = macro Macros.fooImpl
}
Then you can use the #foo annotation to satisfy some Trait definition:
trait Foo { def foo: Int}
#foo
class Bar extends Foo //compiles
(new Bar).foo //5
You can read more about Macro annotations here.

Answer 2

You cannot override an abstract method with a macro. However, you can override a concrete method, even if that concrete method itself overrides an abstract method. So, if you introduce an intermediary trait with a default implementation, you can have the desired outcome. For example:
object Macros {
def someMacro(c: Context): c.Expr[Int] = {
import c.universe._
c.Expr[Int](Literal(Constant(5)))
}
}
trait Foo {
def foo: Int
}
trait FooWithDefault extends Foo {
override def foo: Int = 0
}
class Bar extends FooWithDefault {
override def foo: Int = macro Macros.someMacro
}
(new Bar).foo //5
This does lead to some unexpected behavior, so be careful:
val b: Foo = new Bar
b.foo //java.lang.AbstractMethodError
val b: FooWithDefault = new Bar
b.foo //java.lang.AbstractMethodError
This is explained in futher detail in the issue SI-7657, where it is explained:
Currently we allow macros to override non-abstract methods (in order
to provide performance enhancements such as foreach for
collections), and we also disallow macros to override abstract methods
(otherwise downcasting might lead to AbstractMethodErrors).
This patch fixes an oversight in the disallowing rule that prohibited
macros from overriding a concrete method if that concrete method
itself overrides an abstract method. RefCheck entertains all
overriding pairs, not only the immediate ones, so the disallowing rule
was triggered.
Now macros can override abstract methods if and only if
either the base type or the self type contain a matching non-abstract
method.