import scala.language.experimental.macros
import scala.reflect.runtime.{ currentMirror => cm }
import scala.reflect.runtime.{ universe => ru }
import scala.tools.reflect.ToolBox

class A[T] {
  def foo(lam: T => Any): Unit = macro FooMacros.fooImpl[T]
}
object B {
  def fooTree[T](lam: T => Any, expr: ru.Expr[T => Any], tp: ru.TypeTag[T]): Unit = {
    // no inferred types in the trees
    println(expr)
    expr.tree.asInstanceOf[ru.FunctionApi].vparams.foreach(t => println((t, t.tpe)))

    // Approach 1: make a copy of the Function node with `Trade` as the explicit parameter
    // type
    import ru._
    val tree2 = expr.tree match {
      case Function(param :: Nil, body) =>
        val newTpt = TypeTree(tp.tpe)
        Function(treeCopy.ValDef(param, param.mods, param.name, newTpt, param.rhs) :: Nil, body)
    }
    println(tree2)

    // Approach 2: typecheck the tree with the original expected type of `Trade => Any`.
    import scala.tools.reflect.ToolBox
    val tb = reflect.runtime.currentMirror.mkToolBox()
    implicit val implicitTT = tp
    val typed = tb.typeCheck(expr.tree, pt = typeOf[T => Any])
    println(s"typed: $typed")
  }
}

object FooMacros {
  import scala.reflect.macros.Context

  def fooImpl[T: c.WeakTypeTag](c: Context)(lam: c.Expr[T => Any]): c.Expr[Unit] = {
    import c.{ universe => cu }
    val fExpr = c.Expr[ru.Expr[T => Any]](c.reifyTree(cu.treeBuild.mkRuntimeUniverseRef, cu.EmptyTree, c.typeCheck(lam.tree)))
    // reify (by design) won't carry inferred types to the next meta-level. Instead, we reify the inferred
    // type argument of the macro application, and transport that up a level. This enables us to typecheck
    // at that level and recover the inferred types.
    val fType = c.reifyType(cu.treeBuild.mkRuntimeUniverseRef, cu.EmptyTree, cu.weakTypeOf[T])
    cu.reify { B.fooTree(lam.splice, fExpr.splice, c.Expr[scala.reflect.runtime.universe.TypeTag[T]](fType).splice ) }
  }
}

class Trade(val id: String, val symbol: String, val amount: Int)

object FreeVarTest {

  val c = "xx"

  def main(args: Array[String]): Unit = {
    var freevar = "ms"
    val am = 20
    val a = new A[Trade]
    println("try more")
    a.foo(t => t.id == freevar && (t.amount < am || t.symbol != c))
  }
}