access default values of any class, not just case classes

Author: cvogt

src/main/scala/Defaults.scala

@@ -1,36 +1,34 @@
 package org.cvogt.scala
 
-import scala.reflect.macros.whitebox.Context
-import scala.language.dynamics
 import scala.language.experimental.macros
+import scala.reflect.macros.whitebox.Context
 
 object Defaults {
  /** returns the given type's default values in an anonymous class instance */
- def apply[T]: Any = macro DefaultsMacros.defaults[T]
+ def apply[T]: AnyRef = macro DefaultsMacros.defaults[T]
 }
 
 class DefaultsMacros( val c: Context ) {
  import c.universe._
- def defaults[T: c.WeakTypeTag] = {
+ def defaults[T: c.WeakTypeTag]: Tree = {
  val T = weakTypeOf[T]
- if ( !isCaseClass( T ) )
- c.error( c.enclosingPosition, s"not a case class: $T" )
- val defs = caseClassFieldsTypes( T ).collect {
+ val defs = constructorFieldsTypesDefaults( T ).collect {
  case ( name, tpe, Some( default ) ) => q"def ${TermName( name )}: $tpe = $default"
  }
  q"new{ ..$defs }"
  }
 
- private def isCaseClass( tpe: Type ) = tpe.typeSymbol.isClass && tpe.typeSymbol.asClass.isCaseClass
-
- private def caseClassFieldsTypes( tpe: Type ): List[( String, Type, Option[Tree] )] = {
- tpe.companion.member( TermName( "apply" ) ).asTerm.alternatives.find( _.isSynthetic ).get.asMethod.paramLists.flatten.zipWithIndex.map {
+ def constructorFieldsTypesDefaults( tpe: Type ): List[( String, Type, Option[Tree] )] = {
+ val m = tpe.decls.collectFirst {
+ case m: MethodSymbol if m.isPrimaryConstructor => m
+ }.head.paramLists.flatten.zipWithIndex
+ m.map {
  case ( field, i ) =>
  (
  field.name.toTermName.decodedName.toString,
  field.infoIn( tpe ),
  {
- val method = TermName( s"apply$$default$$${i + 1}" )
+ val method = TermName( "<init>$default$"+(i + 1) ).encodedName.toTermName
  tpe.companion.member( method ) match {
  case NoSymbol => None
  case _ => Some( q"${tpe.typeSymbol.companion}.$method" )

src/test/scala/DefaultsTest.scala

@@ -5,11 +5,15 @@ import org.cvogt.scala.Defaults
 import org.scalatest.FunSuite
 
 case class Foo(i: Int = 5, s: String)
+class Bar(i: Int = 5, s: String)
 class DefaultsTest extends FunSuite {
- test( "case class" ) {
- val d = Defaults[Foo]
+ test( "defaults" ) {
+ val f = Defaults[Foo]
+ val b = Defaults[Bar]
 
  import scala.language.reflectiveCalls
- assert( d.i === 5 )
+ assert( f.i === 5 )
+ import scala.language.reflectiveCalls
+ assert( b.i === 5 )
  }
 }