Reuse interpretCall in proxies

Author: nicolasstucki

tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala

@@ -23,12 +23,22 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
   def withLocalValues[T](syms: List[Symbol], values: List[LocalValue])(in: implicit Env => T)(implicit env: Env): T =
     in(env ++ syms.zip(values))
 
+  def interpretCall(instance: AbstractAny, sym: DefSymbol, args: List[AbstractAny]): Result = {
+    // TODO
+    // withLocalValue(`this`, instance) {
+      val syms = sym.tree.paramss.headOption.getOrElse(Nil).map(_.symbol)
+      withLocalValues(syms, args.map(LocalValue.valFrom(_))) {
+        eval(sym.tree.rhs.get)
+      }
+    // }
+  }
+
   def interpretCall(fn: Term, argss: List[List[Term]]): Result = {
-    val env0 = fn match {
-      case Term.Select(prefix, _) =>
-        val pre = eval(prefix)
-        implicitly[Env] // FIXME add pre to the env as `this`
-      case _ => implicitly[Env]
+    fn match {
+      case Term.Select (prefix, _) =>
+        val pre = eval (prefix)
+        // TODO use
+      case _ =>
     }
     val evaluatedArgs = argss.flatten.map(arg => LocalValue.valFrom(eval(arg)))
     val IsDefSymbol(sym) = fn.symbol

tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala

@@ -31,15 +31,10 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
               val symbol = sym.methods.find(_.name == method.getName).get
 
               if (symbol.isDefinedInCurrentRun) {
-                // TODO use `super.interpretCall(...)`
+                val argsList = if (args == null) Nil else args.toList
                 symbol match {
                   case IsDefSymbol(symbol) =>
-                    val args1 = if (args == null) Nil else args.toList
-                    val evaluatedArgs = args1.map(arg => LocalValue.valFrom(arg))
-                    val syms = symbol.tree.paramss.headOption.getOrElse(Nil).map(_.symbol)
-                    withLocalValues(syms, evaluatedArgs) {
-                      eval(symbol.tree.rhs.get).asInstanceOf[Object]
-                    }
+                    interpretCall(this, symbol, argsList).asInstanceOf[Object]
                 }
               }
               else {