evaluator.scala

package evaluator

import scala.language.experimental.macros
import scala.reflect.macros.Context

object Evaluator {
  def preprocess[T]: T = ???

  def evaluate[A] = macro evaluateImpl[A]

  def evaluateImpl[A: c.WeakTypeTag](c: Context): c.Expr[A] = {
    import c.universe._

    val tpe = weakTypeOf[A]
    val sym = tpe.typeSymbol.asClass

    require(sym.isCaseClass)

    val companionSym = sym.companionSymbol
    val companionTpe = companionSym.typeSignature
    val applyMethod = companionTpe.member(newTermName("apply")).asMethod

    val argTypes = applyMethod.paramss.flatten.map(_.typeSignature)

    val tpeTypeArgs = tpe match {
      case TypeRef(_, _, args) => args
    }

    val arguments = argTypes.map { argTpe =>
      q"evaluator.Evaluator.preprocess[$argTpe]"
    }

    c.Expr(q"$companionSym.apply[..$tpeTypeArgs](..$arguments)")
  }
}