Как получить доступ к значениям параметров по умолчанию через отражение Scala?

Скажем, у меня есть класс:

case class Foo(id: Int, name: String, note: Option[String] = None)

Как конструктор, так и метод apply в автоматически создаваемом объекте-компаньоне принимают три параметра. При просмотре с помощью отражения отмечен третий параметр (примечание):

p.isParamWithDefault = true

Кроме того, при проверке я могу найти метод, который создает значение в сопутствующем объекте:

method <init>$default$3

method apply$default$3

У обоих и есть:

m.isParamWithDefault = true

Однако я не могу ничего найти в TermSymbol для параметра notes, который на самом деле указывает мне на правильные методы, чтобы получить значение по умолчанию или что-либо из вышеперечисленных MethodSymbols, которые указывают на TermSymbol для параметра.

Есть ли прямой способ связать TermSymbol для параметра с методом, который генерирует значение по умолчанию? Или мне нужно что-то делать, например, проверять имена методов на сопутствующем объекте?

Мне это интересно как для примера конструктора case case, который я здесь, так и для обычных методов.

Ответ 1

Существуют степени kludge.

Пример кода этот ответ, вставляемый ниже.

Итак, как я уже говорил, форма имени находится в спецификации в 4.6, 6.6.1. Это не ad-hoc. For every parameter pi , j with a default argument a method named f $default$n is generated which computes the default argument expression.

Отсутствие структурированной способности доступа и восстановления этих сгенерированных имен является известной проблемой (с текущим потоком в ML).

import reflect._
import scala.reflect.runtime.{ currentMirror => cm }
import scala.reflect.runtime.universe._

// case class instance with default args

// Persons entering this site must be 18 or older, so assume that
case class Person(name: String, age: Int = 18) {
  require(age >= 18)
}

object Test extends App {

  // Person may have some default args, or not.
  // normally, must Person(name = "Guy")
  // we will Person(null, 18)
  def newCase[A]()(implicit t: ClassTag[A]): A = {
    val claas = cm classSymbol t.runtimeClass
    val modul = claas.companionSymbol.asModule
    val im = cm reflect (cm reflectModule modul).instance
    defaut[A](im, "apply")
  }

  def defaut[A](im: InstanceMirror, name: String): A = {
    val at = newTermName(name)
    val ts = im.symbol.typeSignature
    val method = (ts member at).asMethod

    // either defarg or default val for type of p
    def valueFor(p: Symbol, i: Int): Any = {
      val defarg = ts member newTermName(s"$name$$default$$${i+1}")
      if (defarg != NoSymbol) {
        println(s"default $defarg")
        (im reflectMethod defarg.asMethod)()
      } else {
        println(s"def val for $p")
        p.typeSignature match {
          case t if t =:= typeOf[String] => null
          case t if t =:= typeOf[Int]    => 0
          case x                         => throw new IllegalArgumentException(x.toString)
        }
      }
    }
    val args = (for (ps <- method.paramss; p <- ps) yield p).zipWithIndex map (p => valueFor(p._1,p._2))
    (im reflectMethod method)(args: _*).asInstanceOf[A]
  }

  assert(Person(name = null) == newCase[Person]())
}

Ответ 2

Вы можете сделать это, не делая предположений о сгенерированных именах - путем литья во внутренний API:

scala> :power
** Power User mode enabled - BEEP WHIR GYVE **
** :phase has been set to 'typer'.          **
** scala.tools.nsc._ has been imported      **
** global._, definitions._ also imported    **
** Try  :help, :vals, power.<tab>           **

scala> case class Foo(id: Int, name: String, note: Option[String] = None)
defined class Foo

scala> val t = typeOf[Foo.type]
t: $r.intp.global.Type = Foo.type

scala> t.declaration(nme.defaultGetterName(nme.CONSTRUCTOR, 3))
res0: $r.intp.global.Symbol = method <init>$default$3

scala> t.declaration(nme.defaultGetterName(newTermName("apply"), 3))
res1: $r.intp.global.Symbol = method apply$default$3

Конечно, в некотором смысле это не лучше, поскольку указано имя mangling, а внутренний API - нет, но это может быть более удобно.