Add typeChecks to tasty reflect

Author: liufengyun

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -3,13 +3,16 @@ package tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import dotty.tools.dotc.ast.tpd.TreeOps
+import dotty.tools.dotc.typer.Typer
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.tastyreflect.FromSymbol.{definitionFromSym, packageDefFromSym}
+import dotty.tools.dotc.parsing.Parsers.Parser
+import dotty.tools.dotc.util.SourceFile
 
 import scala.tasty.reflect.Kernel
 
@@ -47,6 +50,23 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Settings_color(self: Settings): Boolean = self.color.value(rootContext) == "always"
 
+  //
+  // MISC
+  //
+  /** Whether the code type checks in the given context?
+   *
+   *  @param code The code to be type checked
+   *
+   *  The code should be a sequence of expressions or statements that may appear in a block.
+   */
+  def typeChecks(code: String)(implicit ctx: Context): Boolean = {
+    val tree = new Parser(SourceFile.virtual("tasty-reflect", code)).block()
+
+    val ctx2 = ctx.fresh.setNewTyperState().setTyper(new Typer)
+    ctx2.typer.typed(tree)(ctx2)
+    !ctx2.reporter.hasErrors
+  }
+
   //
   // TREES
   //

library/src/scala/tasty/Reflection.scala

@@ -27,6 +27,15 @@ abstract class Reflection
   def typeOf[T: scala.quoted.Type]: Type =
     implicitly[scala.quoted.Type[T]].unseal.tpe
 
+
+  /** Whether the code type checks in the given context?
+   *
+   *  @param code The code to be type checked
+   *
+   *  The code should be a sequence of expressions or statements that may appear in a block.
+   */
+  def typeChecks(code: String)(implicit ctx: Context): Boolean = kernel.typeChecks(code)(ctx)
+
   val util: reflect.utils.TreeUtils { val reflect: self.type } = new reflect.utils.TreeUtils {
     val reflect: self.type = self
   }

library/src/scala/tasty/reflect/Kernel.scala

@@ -153,6 +153,17 @@ trait Kernel {
 
   def Settings_color(self: Settings): Boolean
 
+  //
+  // MISC
+  //
+  /** Whether the code type checks in the given context?
+   *
+   *  @param code The code to be type checked
+   *
+   *  The code should be a sequence of expressions or statements that may appear in a block.
+   */
+  def typeChecks(code: String)(implicit ctx: Context): Boolean
+
   //
   // TREES
   //
@@ -695,7 +706,7 @@ trait Kernel {
   //
   // PATTERNS
   //
-  
+
   /** Pattern tree of the pattern part of a CaseDef */
   type Pattern <: AnyRef
 

tests/run-with-compiler/reflect-typeChecks/assert_1.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+import scala.tasty._
+
+object scalatest {
+
+  inline def assertCompiles(inline code: String): Unit = ${ assertImpl(code, true) }
+  inline def assertNotCompile(inline code: String): Unit = ${ assertImpl(code, false) }
+
+  def assertImpl(code: String, expect: Boolean)(implicit refl: Reflection): Expr[Unit] = {
+    import refl._
+
+    val actual = typeChecks(code)
+
+    '{ assert(${expect.toExpr} == ${actual.toExpr}) }
+  }
+}

tests/run-with-compiler/reflect-typeChecks/test_2.scala

@@ -0,0 +1,15 @@
+object Test {
+  import scalatest._
+
+  trait Eq[T]
+  implicit val eq: Eq[Int] = new Eq[Int] {}
+
+  implicit class AnyOps[T](x: T) {
+    def === (y: T)(implicit c: Eq[T]) = x == y
+  }
+
+  def main(args: Array[String]): Unit = {
+    assertCompiles("5 === 5")
+    assertNotCompile("5.6 === 7.7")
+  }
+}