如何在Dotty宏中调用作用域内的泛型Trait方法foo

核心问题分析 #

你遇到的两个关键问题：

1. 泛型方法foo[T]的调用构造错误，缺少类型参数绑定或实例接收者
2. 无法确保调用当前作用域中正确的重写版本

1. 正确构造泛型实例方法调用 #

foo是实例泛型方法，必须满足两个条件才能正确调用：

• 必须有实例接收者（this，因为是类/对象的成员方法）
• 必须处理泛型类型参数（让编译器自动推断或显式指定）

修复后的宏调用构造代码 #

import scala.quoted.*

def generateFooCall(x: Expr[Int])(using Quotes): Expr[Etc] = {
  import Quotes.reflect.*

  // 查找当前作用域中的foo方法符号
  def findFoo(owner: Symbol): Option[Symbol] =
    if (owner.isNoSymbol) None
    else owner.declaredMethod("foo").headOption.orElse(findFoo(owner.maybeOwner))

  findFoo(currentOwner) match {
    case Some(fooSym) =>
      // 1. 获取当前实例的this作为接收者
      val thisTerm = This(currentOwner.owner)
      // 2. 选择当前实例的foo方法
      val fooSelect = Select(thisTerm, fooSym)
      // 3. 构造类型应用（空列表让编译器自动推断T的类型）
      val typeApplied = TypeApply(fooSelect, Nil)
      // 4. 构造方法调用
      val call = Apply(typeApplied, List(x.asTerm))
      call.asExprOf[Etc]

    case None =>
      // 错误处理：找不到foo时返回空实现或报错
      report.warning("未找到foo方法，插入空实现")
      '{ Etc.empty } // 假设Etc有empty静态方法
  }
}

2. 确保调用正确的重写版本 #

无需手动查找重写的方法符号，利用Scala的动态绑定特性：只要构造this.foo(x)的调用，编译器会自动根据当前实例的实际类型（A是Foo，B是SubFoo）调用对应的重写实现。

3. 实现类级宏注解（@rewriteFoo） #

如果要自动替换类中所有invokeFoo的实现，编写类宏注解即可：

宏注解实现 #

import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.quoted.*

@compileTimeOnly("需要启用Scala宏支持")
class rewriteFoo extends StaticAnnotation {
  def transform(using Quotes)(tree: Quotes.reflect.Definition): Quotes.reflect.Definition = {
    import Quotes.reflect.*

    tree match {
      case cls: ClassDef =>
        // 遍历类体成员，替换invokeFoo方法
        val newBody = cls.body.map {
          case dd: DefDef if dd.name == "invokeFoo" =>
            // 获取方法参数x
            val xParam = dd.paramss.head.head
            val xExpr = Ref(xParam.symbol).asExprOf[Int]
            // 生成foo调用代码
            val fooCallTerm = generateFooCall(xExpr).asTerm
            // 替换方法体
            dd.copy(rhs = Some(fooCallTerm))
          case other => other
        }
        cls.copy(body = newBody)

      case _ =>
        report.error("@rewriteFoo只能用于类")
        tree
    }
  }
}

使用示例 #

@rewriteFoo
class X {
  object A extends Foo {
    def invokeFoo(x: Int): Etc = ??? // 宏会替换为this.foo(x)，调用Foo的默认实现
  }
  object B extends SubFoo {
    def invokeFoo(x: Int): Etc = ??? // 宏会替换为this.foo(x)，调用SubFoo的重写实现
  }
}

关键注意事项 #

• 实例方法必须通过this作为接收者，不能直接引用方法符号
• 泛型方法调用用TypeApply包裹，空类型参数列表交给编译器自动推断
• 宏中报错用report.errorAndAbort，警告用report.warning，确保编译时反馈问题

内容的提问来源于stack exchange，提问作者CT075