WIP

Author: nicolasstucki

compiler/src/dotty/tools/dotc/interpreter/Interpreter.scala

@@ -3,20 +3,16 @@ package interpreter
 
 import java.io.{PrintWriter, StringWriter}
 
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.Trees._
-import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.quoted.Quoted
 import dotty.tools.dotc.util.Positions.Position
 
 import scala.reflect.ClassTag
 import java.net.URLClassLoader
-import java.lang.reflect.Constructor
 import java.lang.reflect.Method
 
 /** Tree interpreter that can interpret
@@ -28,7 +24,7 @@ import java.lang.reflect.Method
  *  The interpreter assumes that all calls in the trees are to code that was
  *  previously compiled and is present in the classpath of the current context.
  */
-class Interpreter(implicit ctx: Context) {
+class Interpreter(pos: Position)(implicit ctx: Context) {
 
   private[this] val classLoader = {
     val urls = ctx.settings.classpath.value.split(':').map(cp => java.nio.file.Paths.get(cp).toUri.toURL)
@@ -38,9 +34,9 @@ class Interpreter(implicit ctx: Context) {
   /** Returns the interpreted result of interpreting the code a call to the symbol with default arguments.
    *  Return Some of the result or None if some error happen during the interpretation.
    */
-  def interpretCallToSymbol[T](sym: Symbol)(implicit pos: Position, ct: ClassTag[T]): Option[T] = {
+  def interpretCallToSymbol[T](sym: Symbol)(implicit ct: ClassTag[T]): Option[T] = {
     try {
-      val clazz = loadClass(sym.owner.companionModule.fullName)(pos)
+      val (clazz, instance) = loadModule(sym.owner)
       val paramClasses = paramsSig(sym)
       val interpretedArgs = paramClasses.map { clazz =>
         if (clazz == classOf[Boolean]) false.asInstanceOf[Object]
@@ -54,9 +50,10 @@ class Interpreter(implicit ctx: Context) {
         else null
       }
 
+
       val method = getMethod(clazz, sym.name, paramClasses)
 
-      val o = stopIfRuntimeException(method.invoke(null, interpretedArgs: _*))(pos)
+      val o = stopIfRuntimeException(method.invoke(instance, interpretedArgs: _*))
 
       o match {
         case obj: T => Some(obj)
@@ -72,7 +69,18 @@ class Interpreter(implicit ctx: Context) {
     }
   }
 
-  private def loadClass(name: Name)(implicit pos: Position): Class[_] = {
+  private def loadModule(sym: Symbol): (Class[_], Object) = {
+    if (sym.owner.is(Package)) {
+      // is top level object
+      (loadClass(sym.companionModule.fullName), null)
+    } else {
+      // nested object in an object
+      val clazz = loadClass(sym.fullNameSeparated(FlatName))
+      (clazz, clazz.newInstance().asInstanceOf[Object])
+    }
+  }
+
+  private def loadClass(name: Name): Class[_] = {
     try classLoader.loadClass(name.toString)
     catch {
       case _: ClassNotFoundException =>
@@ -81,7 +89,7 @@ class Interpreter(implicit ctx: Context) {
     }
   }
 
-  private def getMethod(clazz: Class[_], name: Name, paramClasses: List[Class[_]])(implicit pos: Position): Method = {
+  private def getMethod(clazz: Class[_], name: Name, paramClasses: List[Class[_]]): Method = {
     try clazz.getMethod(name.toString, paramClasses: _*)
     catch {
       case _: NoSuchMethodException =>
@@ -90,7 +98,7 @@ class Interpreter(implicit ctx: Context) {
     }
   }
 
-  private def stopIfRuntimeException[T](thunk: => T)(implicit pos: Position): T = {
+  private def stopIfRuntimeException[T](thunk: => T): T = {
     try thunk
     catch {
       case ex: RuntimeException =>

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -515,7 +515,7 @@ class ReifyQuotes extends MacroTransformWithImplicits with InfoTransformer {
             }
 
             val tree1 =
-              if (level == 0) cpy.Inlined(tree)(call, bindings, Splicer.splice(body, call, bindings).withPos(tree.pos))
+              if (level == 0) cpy.Inlined(tree)(call, bindings, Splicer.splice(body, call, bindings, tree.pos).withPos(tree.pos))
               else seq(stagedBindings, cpy.Select(expansion)(cpy.Inlined(tree)(call, splicedBindings, body), name))
             val tree2 = transform(tree1)
 

compiler/src/dotty/tools/dotc/transform/Splicer.scala

@@ -21,12 +21,12 @@ object Splicer {
    *  and for `~xyz` the tree of `xyz` is interpreted for which the
    *  resulting expression is returned as a `Tree`
    */
-  def splice(tree: Tree, call: Tree, bindings: List[Tree])(implicit ctx: Context): Tree = tree match {
+  def splice(tree: Tree, call: Tree, bindings: List[Tree], pos: Position)(implicit ctx: Context): Tree = tree match {
     case Quoted(quotedTree) => quotedTree
-    case _ => reflectiveSplice(tree, call, bindings)
+    case _ => reflectiveSplice(tree, call, bindings, pos)
   }
 
-  private def reflectiveSplice(tree: Tree, call: Tree, bindings: List[Tree])(implicit ctx: Context): Tree = {
+  private def reflectiveSplice(tree: Tree, call: Tree, bindings: List[Tree], pos: Position)(implicit ctx: Context): Tree = {
     val liftedArgs = {
       val bindMap = bindings.map {
         case vdef: ValDef => (vdef.rhs, ref(vdef.symbol))
@@ -54,13 +54,12 @@ object Splicer {
       liftArgs(call.symbol.info, allArgs(call, Nil))
     }
 
-    implicit val pos: Position = tree.pos
-    val interpreter = new Interpreter
+    val interpreter = new Interpreter(pos)
     val interpreted = interpreter.interpretCallToSymbol[Seq[Any] => Object](call.symbol)
-    interpreted.flatMap(lambda => evaluateLambda(lambda, liftedArgs)).fold(tree)(PickledQuotes.quotedExprToTree)
+    interpreted.flatMap(lambda => evaluateLambda(lambda, liftedArgs, pos)).fold(tree)(PickledQuotes.quotedExprToTree)
   }
 
-  private def evaluateLambda(lambda: Seq[Any] => Object, args: Seq[Any])(implicit pos: Position, ctx: Context): Option[scala.quoted.Expr[_]] = {
+  private def evaluateLambda(lambda: Seq[Any] => Object, args: Seq[Any], pos: Position)(implicit ctx: Context): Option[scala.quoted.Expr[_]] = {
     try Some(lambda(args).asInstanceOf[scala.quoted.Expr[_]])
     catch {
       case ex: scala.quoted.QuoteError =>

tests/pos/quote-nested-object/Macro_1.scala

@@ -0,0 +1,25 @@
+
+import scala.quoted._
+
+object Macro {
+
+
+  object Implementation {
+
+    inline def plus(inline n: Int, m: Int): Int = ~plus(n, '(m))
+
+    def plus(n: Int, m: Expr[Int]): Expr[Int] =
+      if (n == 0) m
+      else '{ ~n.toExpr + ~m }
+
+    object Implementation2 {
+
+      inline def plus(inline n: Int, m: Int): Int = ~plus(n, '(m))
+
+      def plus(n: Int, m: Expr[Int]): Expr[Int] =
+        if (n == 0) m
+        else '{ ~n.toExpr + ~m }
+    }
+  }
+
+}

tests/pos/quote-nested-object/Test_2.scala

@@ -0,0 +1,12 @@
+object PowerInlined1 {
+  import Macro.Implementation._
+
+  plus(0, 2)
+  plus(1, 3)
+
+  Macro.Implementation.plus(0, 2)
+  Macro.Implementation.plus(1, 3)
+
+  Macro.Implementation.Implementation2.plus(0, 2)
+  Macro.Implementation.Implementation2.plus(1, 3)
+}