当我调用我的 scala 宏时，使用“MatchError：AnyRef”使编译器崩溃

Question

编辑：我已经解决了这个问题——我在recursiveOpt 上错误地调用了.map(f => f.typeSignature.asInstanceOf[TypeRef].args.head)，这意味着field.name 在我的copy 方法中给了我错误的字段名称。我已经删除了map，现在一切正常。

---

我正在编写一个宏，它将为案例类创建更新方法的映射，例如

case class Inner(innerStr: String)
case class Outer(outerStr: String, inner: Inner, innerOpt: Option[Inner])

应该为 Outer 生成一个更新地图，类似于

val innerMap = Map("innerStr" -> {(json: JsValue) => Try{(inner: Inner) => inner.copy(innerStr = json)}})

val outerMap = Map("outerStr" -> {(json: JsValue) => Try{(outer: Outer) => outer.copy(outerStr = json)}},
  "inner.innerStr" -> {(json: JsValue) => Try{(outer: Outer) => innerMap.get("innerStr").get(json).flatMap(update => outer.copy(inner = update(outer.inner)))},
  "innerOpt.innerStr" -> {(json: JsValue) => Try{(outer: Outer) => innerMap.get("innerStr").get(json).flatMap(update => outer.copy(inner = outer.inner.map(inner => update(inner))))})

然后会被称为

val oldOuter = Outer("str", Inner("str"), Some(Inner("str")))
val updatedOuter = outerMap.get("inner.innerStr").get(JsString("newStr")).get(oldOuter)

这个想法是，给定一个 json kv 对，我可以使用键从映射中检索适当的更新方法，然后使用值应用更新，使用隐式转换将 json 值转换为适当的类型。

我的宏适用于扁平案例类的案例，例如Inner(innerStr: String)，对于嵌套案例类，例如Outer(outerStr: String, inner: Inner)。但是，嵌套选项案例类Outer(outerStr: String, innerOpt: Option[Inner]) 的案例正在使编译器崩溃。我不确定我是否在做一些灾难性的错误，或者编译器中是否存在错误，或者第三个选项。这是使用 Scala 2.11.0-M7 REPL 完成的

下面是我的代码——我正在构建一个Map，它接受String 输入而不是JsValue 输入，这样我就不需要将播放框架导入我的REPL。 blacklist 过滤掉不应该在更新映射中的字段（例如，我们应用它的案例类之一具有像“crypted_pa​​ssword”和“salt”这样的字段，这些字段不应该通过通过 REST 发送的 json 进行更新路线）。 baseMethods 为平面情况构造键-> 方法元组，recursiveMethods 为嵌套情况构造键方法元组，recursiveOptMethods 为嵌套选项情况构造键值元组；在宏的底部，这些都合并成一个平面序列并放在Map 中。

我已经测试了recursiveOptMethods quasiquotes 中的代码，以确保我正在构建正确类型的元组序列并且没有发现错误（此外，此代码与recursiveMethods quasiquotes 非常相似，运行正常），并且我已经测试了构造 base、recursive 和 recursiveOpt 符号序列的代码，它们似乎正在完成它们的工作。

任何关于我为什么会导致编译器崩溃的帮助将不胜感激。

---

import scala.language.experimental.macros

def copyTestImpl[T: c.WeakTypeTag](c: scala.reflect.macros.Context)(blacklist: c.Expr[String]*): c.Expr[Map[String, (String) => scala.util.Try[(T) => T]]] = {
  import c.universe._

  val blacklistList: Seq[String] = blacklist.map(e => c.eval(c.Expr[String](c.resetAllAttrs(e.tree))))

  def isCaseClass(tpe: Type): Boolean = tpe.typeSymbol.isClass && tpe.typeSymbol.asClass.isCaseClass

  def isCaseClassOpt(tpe: Type): Boolean = tpe.typeSymbol.name.decoded == "Option" && isCaseClass(tpe.asInstanceOf[TypeRef].args.head)

  def rec(tpe: Type): c.Expr[Map[String, (String) => scala.util.Try[(T) => T]]] = {
    val typeName = tpe.typeSymbol.name.decoded

    val fields = tpe.declarations.collectFirst {
      case m: MethodSymbol if m.isPrimaryConstructor => m
    }.get.paramss.head.filterNot(field => blacklistList.contains(typeName + "." + field.name.decoded))

    val recursive = fields.filter(f => isCaseClass(f.typeSignature))
    val recursiveOpt = fields.filter(f => isCaseClassOpt(f.typeSignature))
    val base = fields.filterNot(f => isCaseClass(f.typeSignature) || isCaseClassOpt(f.typeSignature))

    val recursiveMethods = recursive.map {
      field => {
        val fieldName = field.name
        val fieldNameDecoded = fieldName.decoded
        val map = rec(field.typeSignature)
        q"""{
            val innerMap = $map
            innerMap.toSeq.map(tuple => ($fieldNameDecoded + "." + tuple._1) -> {
            (str: String) => {
              val innerUpdate = tuple._2(str)
              innerUpdate.map(innerUpdate => (outer: $tpe) => outer.copy($fieldName = innerUpdate(outer.$fieldName)))
            }
        })}"""
      }}

    val recursiveOptMethods = recursiveOpt.map {
      field => {
        val fieldName = field.name
        val fieldNameDecoded = fieldName.decoded
        val map = rec(field.typeSignature.asInstanceOf[TypeRef].args.head)
        q"""{
            val innerMap = $map
            innerMap.toSeq.map(tuple => ($fieldNameDecoded + "." + tuple._1) -> {
            (str: String) => {
              val innerUpdate = tuple._2(str)
              innerUpdate.map(innerUpdate => (outer: $tpe) => outer.copy($fieldName = (outer.$fieldName).map(inner => innerUpdate(inner))))
            }
        })}"""
      }}

    val baseMethods = base.map {
      field => {
        val fieldName = field.name
        val fieldNameDecoded = fieldName.decoded
        val fieldType = field.typeSignature
        val fieldTypeName = fieldType.toString
        q"""{
          $fieldNameDecoded -> {
            (str: String) => scala.util.Try {
              val x: $fieldType = str
              (t: $tpe) => t.copy($fieldName = x)
            }.recoverWith {
              case e: Exception => scala.util.Failure(new IllegalArgumentException("Failed to parse " + str + " as " + $typeName + "." + $fieldNameDecoded + ": " + $fieldTypeName))
            }
         }}"""
      }}

    c.Expr[Map[String, (String) => scala.util.Try[(T) => T]]] {
      q"""{ Map((List(..$recursiveMethods).flatten ++ List(..$recursiveOptMethods).flatten ++ List(..$baseMethods)):_*) }"""
    }
  }

  rec(weakTypeOf[T])
}

def copyTest[T](blacklist: String*) = macro copyTestImpl[T]

---

调用copyTest[Outer]() 时，我的错误的顶部和底部来自 2.11.0-M7 REPL（其中Outer 有一个Option[Inner] 字段）

scala> copyTest[Outer]()

scala.MatchError: AnyRef
    with Product
    with Serializable {
  val innerStr: String
  private[this] val innerStr: String
  def <init>(innerStr: String): Inner
  def copy(innerStr: String): Inner
  def copy$default$1: String @scala.annotation.unchecked.uncheckedVariance
  override def productPrefix: String
  def productArity: Int
  def productElement(x$1: Int): Any
  override def productIterator: Iterator[Any]
  def canEqual(x$1: Any): Boolean
  override def hashCode(): Int
  override def toString(): String
  override def equals(x$1: Any): Boolean
} (of class scala.reflect.internal.Types$ClassInfoType)
    at scala.reflect.internal.Variances$class.inType$1(Variances.scala:181)
    at scala.reflect.internal.Variances$$anonfun$inArgs$1$1.apply(Variances.scala:176)
    at scala.reflect.internal.Variances$$anonfun$inArgs$1$1.apply(Variances.scala:176)
    at scala.reflect.internal.util.Collections$class.map2(Collections.scala:55)
    at scala.reflect.internal.SymbolTable.map2(SymbolTable.scala:14)
    at scala.reflect.internal.Variances$class.inArgs$1(Variances.scala:176)
    at scala.reflect.internal.Variances$class.inType$1(Variances.scala:189)
    at scala.reflect.internal.Variances$$anonfun$inArgs$1$1.apply(Variances.scala:176)
    at scala.reflect.internal.Variances$$anonfun$inArgs$1$1.apply(Variances.scala:176)
    at scala.reflect.internal.util.Collections$class.map2(Collections.scala:55)
    at scala.reflect.internal.SymbolTable.map2(SymbolTable.scala:14)

---

at scala.tools.nsc.typechecker.Analyzer$typerFactory$$anon$3.run(Analyzer.scala:93)
at scala.tools.nsc.Global$Run.compileUnitsInternal(Global.scala:1603)
at scala.tools.nsc.Global$Run.compileUnits(Global.scala:1588)
at scala.tools.nsc.Global$Run.compileSources(Global.scala:1583)
at scala.tools.nsc.interpreter.IMain.compileSourcesKeepingRun(IMain.scala:387)
at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.compileAndSaveRun(IMain.scala:816)
at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.compile(IMain.scala:775)
at scala.tools.nsc.interpreter.IMain$Request.compile$lzycompute(IMain.scala:951)
at scala.tools.nsc.interpreter.IMain$Request.compile(IMain.scala:946)
at scala.tools.nsc.interpreter.IMain.compile(IMain.scala:530)
at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:518)
at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:516)
at scala.tools.nsc.interpreter.ILoop.reallyInterpret$1(ILoop.scala:748)
at scala.tools.nsc.interpreter.ILoop.interpretStartingWith(ILoop.scala:793)
at scala.tools.nsc.interpreter.ILoop.command(ILoop.scala:660)
at scala.tools.nsc.interpreter.ILoop.processLine(ILoop.scala:427)
at scala.tools.nsc.interpreter.ILoop.loop(ILoop.scala:444)
at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply$mcZ$sp(ILoop.scala:862)
at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:848)
at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:848)
at scala.reflect.internal.util.ScalaClassLoader$.savingContextLoader(ScalaClassLoader.scala:95)
at scala.tools.nsc.interpreter.ILoop.process(ILoop.scala:848)
at scala.tools.nsc.MainGenericRunner.runTarget$1(MainGenericRunner.scala:81)
at scala.tools.nsc.MainGenericRunner.process(MainGenericRunner.scala:94)
at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:103)
at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)

That entry seems to have slain the compiler.  Shall I replay
your session? I can re-run each line except the last one.

Answer 1

我发现了问题 - 最初我有 val recursiveOpt = fields.filter(f => isCaseClassOpt(f.typeSignature)).map(f => f.typeSignature.asInstanceOf[TypeRef].args.head)，这意味着当我在 recursiveOpt 字段上调用 ​​field.name 时，我得到了错误的名称。