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,36 @@ 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( // TODO use this instead of ctx.error
+          ctx.error(
+            s"""Error during macro expansion while typing term
+               |term: ${t.show}
+               |with expected type: ${tp.tpe.show}
+               |
+               |  ${stack.takeWhile(filter).mkString("\n  ")}
+             """.stripMargin,
+            t.pos
+          )
+        }
+
+      }
+      typecheck(ctx.fresh)
+      new quoted.Exprs.TreeExpr(t).asInstanceOf[quoted.Expr[T]]
+    }
   }
 
   def termClassTag: ClassTag[Term] = implicitly[ClassTag[Term]]
@@ -304,6 +337,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 +497,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 {

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))