Add Term.toExpr and TypeTree.toType

Author: nicolasstucki

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

@@ -2,11 +2,14 @@ package dotty.tools.dotc.tasty
 
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import dotty.tools.dotc.core
+import dotty.tools.dotc.core.Contexts.FreshContext
 import dotty.tools.dotc.core._
 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
@@ -232,6 +235,34 @@ object TastyImpl extends scala.tasty.Tasty {
   implicit def TermDeco(t: Term): AbstractTerm = new AbstractTerm {
     def pos(implicit ctx: Context): Position = new TastyPosition(t.pos)
     def tpe: Types.Type = t.tpe
+
+    def toExpr[T: quoted.Type](implicit ctx: Context): quoted.Expr[T] = {
+      def typecheck(implicit ctx0: FreshContext) = {
+        ctx0.setTyperState(ctx0.typerState.fresh())
+        ctx0.typerState.setReporter(new Reporter {
+          def doReport(m: MessageContainer)(implicit ctx: Contexts.Context): Unit = ()
+        })
+        val tp = 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
+          )
+        }
+
+      }
+      typecheck(ctx.fresh)
+      new quoted.Exprs.TreeExpr(t).asInstanceOf[quoted.Expr[T]]
+    }
   }
 
   def termClassTag: ClassTag[Term] = implicitly[ClassTag[Term]]
@@ -304,6 +335,7 @@ object TastyImpl extends scala.tasty.Tasty {
   }
 
   val Typed: TypedExtractor = new TypedExtractor {
+    def apply(term: Term, tpt: TypeTree)(implicit ctx: Context): Term = tpd.Typed(term, tpt)
     def unapply(x: Term)(implicit ctx: Context): Option[(Term, TypeTree)] = x match {
       case x: tpd.Typed @unchecked => Some((x.expr, x.tpt))
       case _ => None
@@ -463,6 +495,7 @@ object TastyImpl extends scala.tasty.Tasty {
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree = new AbstractTypeTree {
     def pos(implicit ctx: Context): Position = new TastyPosition(x.pos)
     def tpe: Types.Type = x.tpe
+    def toType(implicit ctx: Context): quoted.Type[_] = new quoted.Types.TreeType(x)
   }
 
   val Synthetic: SyntheticExtractor = new SyntheticExtractor {

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

@@ -38,7 +38,22 @@ object Splicer {
       val interpreter = new Interpreter(pos, classLoader)
       val interpreted = interpreter.interpretCallToSymbol[Seq[Any] => Object](call.symbol)
       val cu = new CompilationUniverse(ctx)
-      interpreted.flatMap(lambda => evaluateLambda(lambda, cu :: liftedArgs, pos)).fold(tree)(PickledQuotes.quotedExprToTree)
+      try {
+        val evaluated = interpreted.map(lambda => lambda(cu :: liftedArgs).asInstanceOf[scala.quoted.Expr[Nothing]])
+        evaluated.fold(tree)(PickledQuotes.quotedExprToTree)
+      } catch {
+        case ex: scala.quoted.QuoteError =>
+          ctx.error(ex.getMessage, pos)
+          EmptyTree
+        case NonFatal(ex) =>
+          val msg =
+            s"""Failed to evaluate inlined quote.
+               |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
+               |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").init.mkString("\n    ")}
+         """.stripMargin
+          ctx.error(msg, pos)
+          EmptyTree
+      }
   }
 
   /** Given the inline code and bindings, compute the lifted arguments that will be used to execute the macro
@@ -74,23 +89,6 @@ object Splicer {
     liftArgs(call.symbol.info, allArgs(call, Nil))
   }
 
-  private def evaluateLambda(lambda: Seq[Any] => Object, args: Seq[Any], pos: Position)(implicit ctx: Context): Option[scala.quoted.Expr[Nothing]] = {
-    try Some(lambda(args).asInstanceOf[scala.quoted.Expr[Nothing]])
-    catch {
-      case ex: scala.quoted.QuoteError =>
-        ctx.error(ex.getMessage, pos)
-        None
-      case NonFatal(ex) =>
-        val msg =
-          s"""Failed to evaluate inlined quote.
-             |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
-             |    ${ex.getStackTrace.takeWhile(_.getClassName != "dotty.tools.dotc.transform.Splicer$").init.mkString("\n    ")}
-         """.stripMargin
-        ctx.error(msg, pos)
-        None
-    }
-  }
-
   /** Tree interpreter that can interpret calls to static methods with it's default arguments
    *
    *  The interpreter assumes that all calls in the trees are to code that was

library/src/scala/tasty/Tasty.scala

@@ -180,7 +180,9 @@ abstract class Tasty {
 
   type Term <: Statement
 
-  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]
@@ -232,6 +234,7 @@ abstract class Tasty {
 
   val Typed: TypedExtractor
   abstract class TypedExtractor {
+    def apply(term: Term, tpt: TypeTree)(implicit ctx: Context): Term
     def unapply(x: Term)(implicit ctx: Context): Option[(Term, TypeTree)]
   }
 
@@ -344,7 +347,9 @@ abstract class Tasty {
 
   type TypeTree <: MaybeTypeTree
 
-  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: MaybeType): Boolean = tpe match {
+      case SymRef(DefDef("Ops", _, _, _, _), _) => true // TODO check that the parent is Asserts
+      case _ => false
+    }
+
+    object OpsTree {
+      def unapply(arg: Term): Option[Term] = arg match {
+        case Apply(TypeApply(term, _), left :: Nil) if isOps(term.tpe) =>
+          Some(left)
+        case _ => None
+      }
+    }
+
+    tree match {
+      case Apply(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,12 +36,9 @@ object Asserts {
 
     tree match {
       case Apply(Select(OpsTree(left), op, _), right :: Nil) =>
-        // FIXME splice the threes directly
-        val lExpr = TastyPrinter.stringOfTree(tasty)(left).toExpr
-        val rExpr = TastyPrinter.stringOfTree(tasty)(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))