How do I access default parameter values via Scala reflection?

by

There are degrees of kludge.

Sample code at this answer, pasted below.

So as I was saying, the form of the name is in the spec at 4.6, 6.6.1. That is not 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.

The lack of structured ability to access and reconstitute these generated names is a known issue (with a current thread on the 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]())
}

More Related Contents:

  1. Generating a class from string and instantiating it in Scala 2.10
  2. Finding type parameters via reflection in Scala 2.10?
  3. How to get ClassTag form TypeTag, or both at same time?
  4. Creating a method definition tree from a method symbol and a body
  5. Scala 2.10 reflection, how do I extract the field values from a case class, i.e. field list from case class
  6. What is a TypeTag and how do I use it?
  7. Scala’s “postfix ops”
  8. Get companion object instance with new Scala reflection API
  9. I want to get the type of a variable at runtime
  10. Pattern matching on generic type in Scala
  11. What’s the easiest way to use reify (get an AST of) an expression in Scala?
  12. Use case of scala.concurrent.blocking
  13. How to access parameter list of case class in a dotty macro
  14. Get a TypeTag from a Type?
  15. Static return type of Scala macros
  16. Scala generic method – No ClassTag available for T
  17. How to know if an object is an instance of a TypeTag’s type?
  18. To check whether my list fulfils the parameters set out in nested loop in scala function
  19. Method parameters validation in Scala, with for comprehension and monads
  20. Where does the “flatmap that s***” idiomatic expression in Scala come from?
  21. Scala: Why does Seq.contains take an Any argument, instead of an argument of the sequence type?
  22. When to use val or def in Scala traits?
  23. Cake pattern with overriding abstract type don’t work with Upper Type Bounds
  24. Overload constructor for Scala’s Case Classes?
  25. Scala Sets contain the same elements, but sameElements() returns false
  26. How to compute cumulative sum using Spark
  27. using variable length argument in scala
  28. Underscore in List.filter
  29. Scala type programming resources
  30. Schema comparison of two dataframes in scala

Leave a Comment