Add a way to know thew classloader of the class at the callsite

Author: nicolasstucki

compiler/src/dotty/tools/dotc/consumetasty/ConsumeTasty.scala

@@ -16,7 +16,7 @@ object ConsumeTasty {
         new TastyFromClass(tastyConsumer)
     }
 
-    val currentClasspath = QuoteDriver.currentClasspath
+    val currentClasspath = QuoteDriver.currentClasspath(getClass.getClassLoader)
     import java.io.File.{ pathSeparator => sep }
     val args = "-from-tasty" :: "-Yretain-trees" :: "-classpath" :: s"$classpath$sep$currentClasspath" :: classes
     (new Consume).process(args.toArray)

compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala

@@ -37,7 +37,7 @@ class QuoteCompiler extends Compiler {
     new ExprRun(this, ctx.addMode(Mode.ReadPositions))
   }
 
-  def outputClassName: TypeName = "Quoted".toTypeName
+  def outputClassName: TypeName = "Generated$Code$From$Quoted".toTypeName
 
   /** Frontend that receives a scala.quoted.Expr or scala.quoted.Type as input */
   class QuotedFrontend(putInClass: Boolean) extends Phase {

compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala

@@ -11,7 +11,11 @@ import scala.quoted.{Expr, Type}
 import scala.quoted.Toolbox
 import java.net.URLClassLoader
 
-class QuoteDriver extends Driver {
+/** Driver to compile quoted code
+  *
+  * @param appClassloader classloader of the application that generated the quotes
+  */
+class QuoteDriver(appClassloader: ClassLoader) extends Driver {
   import tpd._
 
   private[this] val contextBase: ContextBase = new ContextBase
@@ -32,7 +36,9 @@ class QuoteDriver extends Driver {
     val driver = new QuoteCompiler
     driver.newRun(ctx).compileExpr(expr)
 
-    val classLoader = new AbstractFileClassLoader(outDir, this.getClass.getClassLoader)
+    assert(!ctx.reporter.hasErrors)
+
+    val classLoader = new AbstractFileClassLoader(outDir, appClassloader)
 
     val clazz = classLoader.loadClass(driver.outputClassName.toString)
     val method = clazz.getMethod("apply")
@@ -82,7 +88,7 @@ class QuoteDriver extends Driver {
 
   override def initCtx: Context = {
     val ictx = contextBase.initialCtx
-    ictx.settings.classpath.update(QuoteDriver.currentClasspath)(ictx)
+    ictx.settings.classpath.update(QuoteDriver.currentClasspath(appClassloader))(ictx)
     ictx
   }
 
@@ -94,9 +100,9 @@ class QuoteDriver extends Driver {
 
 object QuoteDriver {
 
-  def currentClasspath: String = {
+  def currentClasspath(cl: ClassLoader): String = {
     val classpath0 = System.getProperty("java.class.path")
-    this.getClass.getClassLoader match {
+    cl match {
       case cl: URLClassLoader =>
         // Loads the classes loaded by this class loader
         // When executing `run` or `test` in sbt the classpath is not in the property java.class.path

compiler/src/dotty/tools/dotc/quoted/ToolboxImpl.scala

@@ -9,9 +9,15 @@ import scala.quoted.Exprs.{LiftedExpr, TastyTreeExpr}
 object ToolboxImpl {
   import tpd._
 
-  def make(settings: scala.quoted.Toolbox.Settings): scala.quoted.Toolbox = new scala.quoted.Toolbox {
+  /** Create a new instance of the toolbox using the the classloader of the application.
+    *
+    * @param appClassloader classloader of the application that generated the quotes
+    * @param settings toolbox settings
+    * @return A new instance of the toolbox
+    */
+  def make(settings: scala.quoted.Toolbox.Settings, appClassloader: ClassLoader): scala.quoted.Toolbox = new scala.quoted.Toolbox {
 
-    private[this] val driver: QuoteDriver = new QuoteDriver()
+    private[this] val driver: QuoteDriver = new QuoteDriver(appClassloader)
 
     def run[T](expr: Expr[T]): T = expr match {
       case expr: LiftedExpr[T] =>
@@ -26,4 +32,5 @@ object ToolboxImpl {
 
     def show[T](tpe: Type[T]): String = synchronized(driver.show(tpe, settings))
   }
+
 }

compiler/test-resources/repl/i6007

@@ -1,10 +1,7 @@
 scala> import quoted.Toolbox.Default._
-
 scala> val v = '{ (if true then Some(1) else None).map(v => v+1) }
 val v: quoted.Expr[Option[Int]] = Expr(<pickled tasty>)
-
 scala> v.show
-val res0: String = if (true) scala.Some.apply[scala.Int](1) else scala.None.map[scala.Int](((v: scala.Int) => v.+(1)))
-
+val res0: String = (if (true) scala.Some.apply[scala.Int](1) else scala.None).map[scala.Int](((v: scala.Int) => v.+(1)))
 scala> v.run
-val res1: Option[Int] = Some(2)
+val res1: Option[Int] = Some(2)

library/src/scala/quoted/Toolbox.scala

@@ -16,15 +16,35 @@ object Toolbox {
     implicit def make(implicit settings: Settings): Toolbox = Toolbox.make
   }
 
-  def make(implicit settings: Settings): Toolbox = {
-    val cl = getClass.getClassLoader
-    println(">>>>>")
-    cl.asInstanceOf[java.net.URLClassLoader].getURLs().toList.foreach(println)
+  /** Create a new instance of the toolbox.
+    *
+    * This instance of the toolbox tries to recover the classloader of the application based on
+    * the classloader of the class that call make. This may not always be the correct classloader,
+    * in which case the classloader must be passed explicitly.
+    *
+    * @param settings TODO
+    * @return A new instance of the toolbox
+    */
+  @forceInline def make(implicit settings: Settings): Toolbox = {
+    // Get the name of the class at call site
+    val className = new Throwable().getStackTrace.head.getClassName
+    // We inline to make forName use the classloader of the class at call site
+    val clazz = Class.forName(className)
+    val cl = clazz.getClassLoader
+    make(cl)
+  }
 
+  /** Create a new instance of the toolbox using the the classloader of the application.
+    *
+    * @param appClassloader classloader of the application that generated the quotes
+    * @param settings toolbox settings
+    * @return A new instance of the toolbox
+    */
+  def make(appClassloader: ClassLoader)(implicit settings: Settings): Toolbox = {
     try {
-      val toolboxImplCls = cl.loadClass("dotty.tools.dotc.quoted.ToolboxImpl")
-      val makeMeth = toolboxImplCls.getMethod("make", classOf[Settings])
-      makeMeth.invoke(null, settings).asInstanceOf[Toolbox]
+      val toolboxImplCls = appClassloader.loadClass("dotty.tools.dotc.quoted.ToolboxImpl")
+      val makeMeth = toolboxImplCls.getMethod("make", classOf[Settings], classOf[ClassLoader])
+      makeMeth.invoke(null, settings, appClassloader).asInstanceOf[Toolbox]
     }
     catch {
       case ex: ClassNotFoundException =>

sbt-dotty/sbt-test/sbt-dotty/quoted-example-project/src/main/scala/hello/Hello.scala

@@ -5,29 +5,35 @@ import scala.quoted._
 
 object Main {
 
-  // Needed to run or show quotes
   implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make
 
   def main(args: Array[String]): Unit = {
     val square = stagedPower(2)
-    println("3^2 = " + square(3))
-    println("4.1^2 = " + square(4.1))
-    println()
+
+    assert(Math.pow(3, 2) == square(3))
+
+    square(3)
+    square(4)
+
+    assert(Math.pow(4, 2) == square(4))
+
     val cube = stagedPower(3)
-    println("2.4^3 = " + cube(2.4))
-    println()
+    cube(2)
+
+
+    assert(Math.pow(2, 3) == cube(2))
+
+
 
     val toTheFourth = stagedPower(4)
-    println("3^4 = " + toTheFourth(3))
-    println()
+    assert(Math.pow(3, 4) == toTheFourth(3))
   }
 
   def stagedPower(n: Int): Double => Double = {
     // Code representing the labmda where the recursion is unrolled based on the value of n
     val code = '{ (x: Double) => ${powerCode(n, '{x})}}
 
-    println(s"staged power for n=" + n + ":")
-    println(code.show)
+    code.show
 
     // Evaluate the contents of the code and return it's value
     code.run

tests/run-with-compiler/quote-run-c.check

@@ -1,4 +1,4 @@
 Foo
 false
 Bar
-class Quoted$A$1
+class Generated$Code$From$Quoted$A$1

tests/run-with-compiler/quote-run-with-settings.scala

@@ -19,7 +19,7 @@ object Test {
     println()
 
     val outDir = Paths.get("out/out-quoted-1")
-    val classFile = outDir.resolve("Quoted.class")
+    val classFile = outDir.resolve("Generated$Code$From$Quoted.class")
 
     Files.deleteIfExists(classFile)