Interpret method calls (not only static ones)

Author: nicolasstucki

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

@@ -53,7 +53,18 @@ object IntepretedMain {
     println(x6.isInstanceOf[Int])
     println(x6.isInstanceOf[Long])
     println(x6.asInstanceOf[Int])
+
+
+    val bar = new Bar
+    println(bar.meth() + 5)
+    println(bar.methA(66))
+
+    val ibar = new InterpretedBar
+    println(ibar.meth() + 5)
+    println(ibar.methA(67))
   }
+
+  def foo(x: Int): Unit = println(x)
 }
 
 class InterpretedBar extends IFace {

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

@@ -48,6 +48,10 @@ object Test {
         |true
         |false
         |64
+        |65
+        |66
+        |67
+        |68
         |""".stripMargin
 
     val actualOutput = ps.toString

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

@@ -13,14 +13,20 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
   /** Representation of objects and values in the interpreter */
   type AbstractAny
 
-  def interpretCall(fn: Tree, argss: List[List[Term]])(implicit env: Env): AbstractAny = {
+  def interpretCall(fn: Term, argss: List[List[Term]])(implicit env: Env): AbstractAny = {
+    val env0 = fn match {
+      case Term.Select(prefix, _) =>
+        val pre = eval(prefix)
+        env // FIXME add pre to the env as `this`
+      case _ => env
+    }
     fn.symbol match {
       case IsDefSymbol(sym) =>
         val evaluatedArgs = argss.flatten.map(arg => LocalValue.valFrom(eval(arg)))
-        val env1 = env ++ sym.tree.paramss.headOption.getOrElse(Nil).map(_.symbol).zip(evaluatedArgs)
+        val env1 = env0 ++ sym.tree.paramss.headOption.getOrElse(Nil).map(_.symbol).zip(evaluatedArgs)
         eval(sym.tree.rhs.get)(env1)
       case _ =>
-        env(fn.symbol).get
+        env0(fn.symbol).get
     }
   }
 
@@ -163,9 +169,9 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
 
 
   private object Call {
-    def unapply(arg: Tree): Option[(Tree, List[TypeTree], List[List[Term]])] = arg match {
-      case fn@ Term.Select(_, _) => Some((fn, Nil, Nil))
-      case fn@ Term.Ident(_) => Some((fn, Nil, Nil))
+    def unapply(arg: Tree): Option[(Term, List[TypeTree], List[List[Term]])] = arg match {
+      case Term.IsSelect(fn) => Some((fn, Nil, Nil))
+      case Term.IsIdent(fn) => Some((fn, Nil, Nil))
       case Term.Apply(Call(fn, targs, args1), args2) => Some((fn, targs, args1 :+ args2))
       case Term.TypeApply(Call(fn, _, _), targs) => Some((fn, targs, Nil))
       case _ => None

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

@@ -50,24 +50,37 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
     else jvmReflection.interpretNew(fn.symbol, evaluatedArgss(argss))
   }
 
-  override def interpretCall(fn: Tree, argss: List[List[Term]])(implicit env: Env): Any = {
+  override def interpretCall(fn: Term, argss: List[List[Term]])(implicit env: Env): Any = {
     if (fn.symbol.isDefinedInCurrentRun) super.interpretCall(fn, argss)
     else {
       import Term._
-      // println(fn.show)
-      fn.symbol match {
-        // TODO: obviously
-        case IsDefSymbol(sym) =>
-          val argss2 = evaluatedArgss(argss)
-          // argss2.foreach(println)
-          jvmReflection.interpretStaticMethodCall(fn.symbol.owner, fn.symbol, argss2)
-        case _ =>
-          if (fn.symbol.flags.isObject) {
-            jvmReflection.loadModule(fn.symbol.asVal.moduleClass.get)
+      fn match {
+        case Select(prefix, _) =>
+          fn.symbol match {
+            case IsDefSymbol(sym) =>
+              val pre = eval(prefix).asInstanceOf[Object]
+              val argss2 = evaluatedArgss(argss)
+              jvmReflection.interpretMethodCall(pre, fn.symbol, argss2)
+            case _ =>
+              // TODO not necesarly static?
+              jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
           }
-          // call to a static val
-          else {
-            jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
+        case _ =>
+          // println(fn.show)
+          fn.symbol match {
+            // TODO: obviously
+            case IsDefSymbol(sym) =>
+              val argss2 = evaluatedArgss(argss)
+              // argss2.foreach(println)
+              jvmReflection.interpretStaticMethodCall(fn.symbol.owner, fn.symbol, argss2)
+            case _ =>
+              if (fn.symbol.flags.isObject) {
+                jvmReflection.loadModule(fn.symbol.asVal.moduleClass.get)
+              }
+              // call to a static val
+              else {
+                jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
+              }
           }
       }
     }

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

@@ -54,12 +54,14 @@ class JVMReflection[R <: Reflection & Singleton](val reflect: R) {
   }
 
   def interpretStaticMethodCall(moduleClass: Symbol, fn: Symbol, args: List[Object]): Object = {
+    // TODO can we use interpretMethodCall instead?
     val instance = loadModule(moduleClass)
     val method = getMethod(instance.getClass, fn.name, paramsSig(fn))
-    // println(">>>>>>")
-    // println(moduleClass)
-    // println(fn)
-    // println(method)
+    method.invoke(instance, args: _*)
+  }
+
+  def interpretMethodCall(instance: Object, fn: Symbol, args: List[Object]): Object = {
+    val method = getMethod(instance.getClass, fn.name, paramsSig(fn))
     method.invoke(instance, args: _*)
   }