Evalutate complex type with quasiquote scala, unlifting

Question

I need to compile function and then evaluate it with different parameters of type List[Map[String, AnyRef]]. I have the following code that does not compile with such the type but compiles with simple type like List[Int].

I found that there are just certain implementations of Liftable in scala.reflect.api.StandardLiftables.StandardLiftableInstances

import scala.reflect.runtime.universe
import scala.reflect.runtime.universe._
import scala.tools.reflect.ToolBox


val tb = universe.runtimeMirror(getClass.getClassLoader).mkToolBox()

val functionWrapper =
"""
  object FunctionWrapper {

  def makeBody(messages: List[Map[String, AnyRef]]) = Map.empty

   }""".stripMargin

val functionSymbol = 
tb.define(tb.parse(functionWrapper).asInstanceOf[tb.u.ImplDef])

val list: List[Map[String, AnyRef]] = List(Map("1" -> "2"))

tb.eval(q"$functionSymbol.function($list)")

Getting compilation error for this, how can I make it work?

Error:(22, 38) Can't unquote List[Map[String,AnyRef]], consider using 
... or providing an implicit instance of 
Liftable[List[Map[String,AnyRef]]]
tb.eval(q"$functionSymbol.function($list)")
                                ^

Answer 1

The problem comes not from complicated type but from the attempt to use AnyRef. When you unquote some literal, it means you want the infrastructure to be able to create a valid syntax tree to create an object that would exactly match the object you pass. Unfortunately this is obviously not possible for all objects. For example, assume that you've passed a reference to Thread.currentThread() as a part of the Map. How it could possible work? Compiler is just not able to recreate such a complicated object (not to mention making it the current thread). So you have two obvious alternatives:

1. Make you argument also a Tree i.e. something like this

  def testTree() = {
    val tb = universe.runtimeMirror(getClass.getClassLoader).mkToolBox()

    val functionWrapper =
      """
        |  object FunctionWrapper {
        |
        |    def makeBody(messages: List[Map[String, AnyRef]]) = Map.empty
        |
        |  }
      """.stripMargin

    val functionSymbol =
      tb.define(tb.parse(functionWrapper).asInstanceOf[tb.u.ImplDef])

    //val list: List[Map[String, AnyRef]] = List(Map("1" -> "2"))
    val list = q"""List(Map("1" -> "2"))"""

    val res = tb.eval(q"$functionSymbol.makeBody($list)")
    println(s"testTree = $res")
  }

The obvious drawback of this approach is that you loose type safety at compile time and might need to provide a lot of context for the tree to work

2. Another approach is to not try to pass anything containing AnyRef to the compiler-infrastructure. It means you create some function-like Wrapper:

package so {

  trait Wrapper {
    def call(args: List[Map[String, AnyRef]]): Map[String, AnyRef]
  }

}

and then make your generated code return a Wrapper instead of directly executing the logic and call the Wrapper from the usual Scala code rather than inside compiled code. Something like this:

def testWrapper() = {
  val tb = universe.runtimeMirror(getClass.getClassLoader).mkToolBox()

  val functionWrapper =
    """
      |object FunctionWrapper {
      |  import scala.collection._
      |  import so.Wrapper /* <- here probably different package :) */
      |
      |  def createWrapper(): Wrapper = new Wrapper {
      |    override def call(args: List[Map[String, AnyRef]]): Map[String, AnyRef] = Map.empty
      |  }
      |}
      | """.stripMargin


  val functionSymbol = tb.define(tb.parse(functionWrapper).asInstanceOf[tb.u.ImplDef])

  val list: List[Map[String, AnyRef]] = List(Map("1" -> "2"))

  val tree: tb.u.Tree = q"$functionSymbol.createWrapper()"
  val wrapper = tb.eval(tree).asInstanceOf[Wrapper]
  val res = wrapper.call(list)
  println(s"testWrapper = $res")
}

P.S. I'm not sure what are you doing but beware of performance issues. Scala is a hard language to compile and thus it might easily take more time to compile your custom code than to run it. If performance becomes an issue you might need to use some other methods such as full-blown macro-code-generation or at least caching of the compiled code.