Scala宏中泛型类型E触发‘class type required’错误的排查与优化

你的宏createMacro在处理泛型类型参数E时失败，核心原因是宏是编译期执行的代码：当你调用GenericFactory.create[E](...)时，编译期并不知道E的具体实现类——它只是一个抽象的类型参数，没有对应的类构造信息，所以编译器无法生成new E(...)的字节码，自然会抛出“class type required but E found”的错误。

下面是针对这个问题的具体修复方案，以及降低用户使用成本的替代思路：

1. 直接整合宏到toEither方法（最直接的修复） #

把宏逻辑直接嵌入toEither的实现中，确保在调用点能获取到E的具体类型信息，同时添加构造函数合法性检查，给出友好的编译错误：

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

trait WrapperBase

object EitherHelpers {
  def toEither[T, E <: WrapperBase](priority: Int): Either[E, T] = macro toEitherMacro[T, E]

  def toEitherMacro[T: c.WeakTypeTag, E <: WrapperBase: c.WeakTypeTag](c: blackbox.Context)(priority: c.Expr[Int]): c.Expr[Either[E, T]] = {
    import c.universe._

    val eType = weakTypeTag[E].tpe
    // 检查E是否有(String, Int)参数的构造函数
    val constructor = eType.decl(termNames.CONSTRUCTOR).asMethod
    val paramTypes = constructor.paramLists.flatten.map(_.info)
    val expectedParams = List(weakTypeTag[String].tpe, weakTypeTag[Int].tpe)
    
    if (paramTypes != expectedParams) {
      c.abort(
        c.enclosingPosition,
        s"错误：类型 ${eType.typeSymbol.name} 必须拥有 (String, Int) 类型的构造函数，但实际参数类型为 $paramTypes"
      )
    }

    c.Expr[Either[E, T]](q"""
      val either: Either[String, T] = generateEither()
      either.left.map(s => new $eType(s, $priority))
    """)
  }

  // 你的原有方法示例
  def generateEither[T]: Either[String, T] = ???
}

使用时用户只需要调用：

EitherHelpers.toEither[MyDataType, MyWrapper](10)

如果MyWrapper没有符合要求的构造函数，会直接在编译期抛出清晰的错误提示，完全不需要用户编写隐式工厂。

2. 处理泛型E的边界场景 #

如果你的toEither需要在泛型类/方法中被调用（此时E还是类型参数），可以要求用户提供TypeTag来传递编译期类型信息：

def toEither[T, E <: WrapperBase](priority: Int)(implicit tt: TypeTag[E]): Either[E, T] = macro toEitherMacro[T, E]

// 宏实现中替换为：
val eType = tt.tpe

这种方式仅增加了一个隐式参数的要求，远低于原有的隐式工厂成本。

3. Scala 3 替代方案（更简洁） #

如果项目可以升级到Scala 3，使用inline和编译期API可以完全避免传统宏的复杂性，实现零样板代码：

import scala.compiletime.{error, summonInline}
import scala.quoted.*

trait WrapperBase

object EitherHelpers {
  inline def toEither[T, E <: WrapperBase](priority: Int): Either[E, T] =
    inline generateEither[T] match {
      case Left(s) => Left(constructWrapper[E](s, priority))
      case Right(t) => Right(t)
    }

  inline def constructWrapper[E <: WrapperBase](s: String, priority: Int): E =
    inline summonInline[Constructor[E, (String, Int)]] match {
      case ctor => ctor.construct(s, priority)
    }

  // 构造器类型类
  trait Constructor[T, Args] {
    def construct(args: Args): T
  }

  // 自动推导符合要求的构造器
  inline given [T, A, B]: Constructor[T, (A, B)] =
    inline try summonInline[ConstructorImpl[T, A, B]]
    catch case _ => error(s"类型 ${typeOf[T]} 没有 (${typeOf[A]}, ${typeOf[B]}) 类型的构造函数")

  trait ConstructorImpl[T, A, B] {
    def construct(a: A, b: B): T
  }

  inline given [T <: WrapperBase]: ConstructorImpl[T, String, Int] =
    (a: String, b: Int) => ${ constructImpl[T]('a, 'b) }

  def constructImpl[T](a: Expr[String], b: Expr[Int])(using Quotes, Type[T]): Expr[T] =
    import quotes.reflect.*
    val tType = TypeRepr.of[T]
    val ctor = tType.typeSymbol.primaryConstructor
    Expr.betaReduce(Apply(Select(New(TypeTree.of[T]), ctor), List(a.asTerm, b.asTerm))).asExprOf[T]

  def generateEither[T]: Either[String, T] = ???
}

用户使用时不需要任何额外代码，直接调用即可，编译期会自动检查构造函数合法性，错误提示也非常清晰。

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