Add Term.toExpr and TypeTree.toType

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -64,7 +64,7 @@ object PickledQuotes {
         case value: Class[_] => ref(defn.Predef_classOf).appliedToType(classToType(value))
         case value => Literal(Constant(value))
       }
-    case expr: TreeExpr[Tree] @unchecked => expr.tree
+    case expr: TreeExpr[Tree, Context] @unchecked => expr.tree
     case expr: FunctionAppliedTo[_, _] =>
       functionAppliedTo(quotedExprToTree(expr.f), quotedExprToTree(expr.x))
   }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1150,7 +1150,7 @@ class TreeUnpickler(reader: TastyReader,
       val args = until(end)(readTerm())
       val splice = splices(idx)
       def wrap(arg: Tree) =
-        if (arg.isTerm) new TreeExpr(arg, PickledQuotes.pickleExpr(arg))
+        if (arg.isTerm) new TreeExpr(arg, ctx)
         else new TreeType(arg)
       val reifiedArgs = args.map(wrap)
       if (isType) {

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

@@ -1,7 +1,9 @@
 package dotty.tools.dotc.quoted
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.printing.RefinedPrinter
 
 import scala.quoted.Expr
@@ -24,8 +26,9 @@ object Toolbox {
     def run(expr: Expr[T]): T = expr match {
       case expr: LiftedExpr[T] =>
         expr.value
-      case expr: TreeExpr[Tree] @unchecked =>
-        new QuoteDriver().run(expr.pickled, runSettings)
+      case expr: TreeExpr[Tree, Context] @unchecked =>
+        val pickled = PickledQuotes.pickleExpr(expr.tree)(expr.ctx).asInstanceOf[Expr[T]]
+        new QuoteDriver().run(pickled, runSettings)
       case _ =>
         new QuoteDriver().run(expr, runSettings)
     }

compiler/src/dotty/tools/dotc/tasty/TastyImpl.scala

@@ -7,6 +7,8 @@ import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.quoted.PickledQuotes
+import dotty.tools.dotc.reporting.Reporter
+import dotty.tools.dotc.reporting.diagnostic.MessageContainer
 import dotty.tools.dotc.util.SourcePosition
 
 import scala.quoted
@@ -218,8 +220,39 @@ object TastyImpl extends scala.tasty.Tasty {
   type Term = tpd.Tree
 
   def TermDeco(t: Term): AbstractTerm = new AbstractTerm {
+
     def pos(implicit ctx: Context): Position = t.pos
+
     def tpe(implicit ctx: Context): Types.Type = t.tpe
+
+    def toExpr[T: quoted.Type](implicit ctx: Context): quoted.Expr[T] = {
+      typecheck(ctx)
+      new quoted.Exprs.TreeExpr(t, ctx).asInstanceOf[quoted.Expr[T]]
+    }
+
+    private def typecheck[T: quoted.Type](ctx: Contexts.Context) = {
+      implicit val ctx0: Contexts.FreshContext = ctx.fresh
+      ctx0.setTyperState(ctx0.typerState.fresh())
+      ctx0.typerState.setReporter(new Reporter {
+        def doReport(m: MessageContainer)(implicit ctx: Contexts.Context): Unit = ()
+      })
+      val tp = QuotedTypeDeco(implicitly[quoted.Type[T]]).toTasty
+      ctx0.typer.typed(t, tp.tpe)
+      if (ctx0.reporter.hasErrors) {
+        val stack = new Exception().getStackTrace
+        def filter(elem: StackTraceElement) =
+          elem.getClassName.startsWith("dotty.tools.dotc.tasty.TastyImpl") ||
+          !elem.getClassName.startsWith("dotty.tools.dotc")
+        throw new quoted.QuoteError(
+          s"""Error during macro expansion while typing term
+             |term: ${t.show}
+             |with expected type: ${tp.tpe.show}
+             |
+             |  ${stack.takeWhile(filter).mkString("\n  ")}
+           """.stripMargin
+        )
+      }
+    }
   }
 
   def termClassTag: ClassTag[Term] = implicitly[ClassTag[Term]]
@@ -460,6 +493,7 @@ object TastyImpl extends scala.tasty.Tasty {
   def TypeTreeDeco(x: TypeTree): AbstractTypeTree = new AbstractTypeTree {
     def pos(implicit ctx: Context): Position = x.pos
     def tpe(implicit ctx: Context): Types.Type = x.tpe.stripTypeVar
+    def toType(implicit ctx: Context): quoted.Type[_] = new quoted.Types.TreeType(x)
   }
 
   def typeTreeClassTag: ClassTag[TypeTree] = implicitly[ClassTag[TypeTree]]

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

@@ -67,7 +67,7 @@ object Splicer {
             assert(!tp.hasAnnotation(defn.InlineParamAnnot))
             // Replace argument by its binding
             val arg1 = bindMap.getOrElse(arg, arg)
-            new scala.quoted.Exprs.TreeExpr(arg1, PickledQuotes.pickleExpr(arg1))
+            new scala.quoted.Exprs.TreeExpr(arg1, ctx)
         }
         args1 ::: liftArgs(tp.resType, args.tail)
       case tp: PolyType =>

library/src/scala/quoted/Expr.scala

@@ -50,8 +50,7 @@ object Exprs {
    *
    *  May contain references to code defined outside this Expr instance.
    */
-  final class TreeExpr[Tree](val tree: Tree, pickle: => Expr[_]) extends quoted.Expr[Any] {
-    def pickled[T]: Expr[T] = pickle.asInstanceOf[Expr[T]]
+  final class TreeExpr[Tree, Context](val tree: Tree, val ctx: Context) extends quoted.Expr[Any] {
     override def toString: String = s"Expr(<raw>)"
   }
 

library/src/scala/tasty/Tasty.scala

@@ -168,7 +168,9 @@ abstract class Tasty {
 
   type Term <: Statement with Parent
 
-  trait AbstractTerm extends Typed with Positioned
+  trait AbstractTerm extends Typed with Positioned {
+    def toExpr[T: quoted.Type](implicit ctx: Context): quoted.Expr[T]
+  }
   implicit def TermDeco(t: Term): AbstractTerm
 
   implicit def termClassTag: ClassTag[Term]
@@ -344,7 +346,9 @@ abstract class Tasty {
 
   type TypeTree <: TypeOrBoundsTree with Parent
 
-  trait AbstractTypeTree extends Typed with Positioned
+  trait AbstractTypeTree extends Typed with Positioned {
+    def toType(implicit ctx: Context): quoted.Type[_]
+  }
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree
 
   implicit def typeTreeClassTag: ClassTag[TypeTree]

tests/neg/tasty-macro-assert/quoted_1.scala

@@ -0,0 +1,71 @@
+import scala.quoted._
+
+import scala.tasty.Universe
+import scala.tasty.util.TastyPrinter
+
+object Asserts {
+
+  implicit class Ops[T](left: T) {
+    def ===(right: T): Boolean = left == right
+    def !==(right: T): Boolean = left != right
+  }
+
+  object Ops
+
+  inline def macroAssert(cond: Boolean): Unit =
+    ~impl('(cond))(Universe.compilationUniverse) // FIXME infer Universe.compilationUniverse within top level ~
+
+  def impl(cond: Expr[Boolean])(implicit u: Universe): Expr[Unit] = {
+    import u._
+    import u.tasty._
+
+    val tree = cond.toTasty
+
+    def isOps(tpe: TypeOrBounds): Boolean = tpe match {
+      case Type.SymRef(DefDef("Ops", _, _, _, _), _) => true // TODO check that the parent is Asserts
+      case _ => false
+    }
+
+    object OpsTree {
+      def unapply(arg: Term): Option[Term] = arg match {
+        case Term.Apply(Term.TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+          Some(left)
+        case _ => None
+      }
+    }
+
+    tree match {
+      case Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil) =>
+        '(assertTrue(~left.toExpr[Boolean])) // Buggy code. To generate the errors
+      case _ =>
+        '(assertTrue(~cond))
+    }
+
+  }
+
+  def assertEquals[T](left: T, right: T): Unit = {
+    if (left != right) {
+      println(
+        s"""Error left did not equal right:
+           |  left  = $left
+           |  right = $right""".stripMargin)
+    }
+
+  }
+
+  def assertNotEquals[T](left: T, right: T): Unit = {
+    if (left == right) {
+      println(
+        s"""Error left was equal to right:
+           |  left  = $left
+           |  right = $right""".stripMargin)
+    }
+
+  }
+
+  def assertTrue(cond: Boolean): Unit = {
+    if (!cond)
+      println("Condition was false")
+  }
+
+}

tests/neg/tasty-macro-assert/quoted_2.scala

@@ -0,0 +1,12 @@
+
+import Asserts._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    macroAssert(true === "cde")
+    macroAssert("acb" === "cde") // error
+    macroAssert(false !== "acb")
+    macroAssert("acb" !== "acb") // error
+  }
+
+}

tests/run/tasty-macro-assert.check

@@ -1,7 +1,7 @@
 Condition was false
 Error left did not equal right:
-  left  = Literal(String(acb))
-  right = Literal(String(cde))
+  left  = acb
+  right = cde
 Error left was equal to right:
-  left  = Literal(String(acb))
-  right = Literal(String(acb))
+  left  = acb
+  right = acb

tests/run/tasty-macro-assert/quoted_1.scala

@@ -1,5 +1,4 @@
 import scala.quoted._
-import dotty.tools.dotc.quoted.Toolbox._
 
 import scala.tasty.Universe
 import scala.tasty.util.TastyPrinter
@@ -37,13 +36,9 @@ object Asserts {
 
     tree match {
       case Term.Apply(Term.Select(OpsTree(left), op, _), right :: Nil) =>
-        // FIXME splice the threes directly
-        val printer = new TastyPrinter(tasty)
-        val lExpr = printer.stringOfTree(left).toExpr
-        val rExpr = printer.stringOfTree(right).toExpr
         op match {
-          case "===" => '(assertEquals(~lExpr, ~rExpr))
-          case "!==" => '(assertNotEquals(~lExpr, ~rExpr))
+          case "===" => '(assertEquals(~left.toExpr[Any], ~right.toExpr[Any]))
+          case "!==" => '(assertNotEquals(~left.toExpr[Any], ~right.toExpr[Any]))
         }
       case _ =>
         '(assertTrue(~cond))