抽象 class 或特征上的宏是否可以应用于所有子类？

Question

Say I have some trait (or abstract class) Foo in a library that is commonly extended by user code and requires some method numArgs :

trait Foo {
  // Number of arguments to the default constructor
  def numArgs: Int
}

Now numArgs is trivial to write but it's obnoxious boiler plate that I'd like to generate. I can do this with reflection, but it's ugly and not portable to alternative backends like ScalaJS, ScalaNative, or GraalVM.

Is it possible to write a macro annotation that I can apply only to Foo ( not requiring it on every subclass of Foo ) such that the method will be generated?

Answer 1

No. Macro annotation on abstract class (or trait) can only change ASTs of this class (trait) and its companion object. You can't change parents, children, siblings etc. It's done so that macro annotations are local in this sense.

Moreover if a trait is not sealed then its subclasses can't even be known at compile time.

If class (trait) and subclasses are nested into some object, then you can annotate the object.

If you want to modify arbitrary trees probably you need compiler plugin or code generation (generation of sources) via Scalameta.

I guess in your use case you can replace macro annotation with def macro

import scala.language.experimental.macros
import scala.reflect.macros.blackbox

def numArgs[A]: Int = macro impl[A]

def impl[A: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
  import c.universe._
  val numArgs = weakTypeOf[A].typeSymbol.asClass.primaryConstructor.asMethod.paramLists.flatten.length
  q"$numArgs"
}

class A(i: Int, s: String)

numArgs[A] // 2

or Shapeless (if subclasses are case classes)

import shapeless.ops.hlist.Length
import shapeless.ops.nat.ToInt
import shapeless.{::, Generic, HList, HNil, Nat}

def numArgs[A] = new PartiallyApplied[A]

class PartiallyApplied[A] {
  def apply[L <: HList, N <: Nat]()(implicit gen: Generic.Aux[A, L], length: Length.Aux[L, N], toInt: ToInt[N]): Int = toInt()
}

case class A(i: Int, s: String)

numArgs[A]() // 2