Address review

Author: liufengyun

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

@@ -60,11 +60,13 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
    *  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
+    val tree = new Parser(SourceFile.virtual("tasty-reflect", code))(ctx2).block()
+
+    !ctx2.reporter.hasErrors && {
+      ctx2.typer.typed(tree)(ctx2)
+      !ctx2.reporter.hasErrors
+    }
   }
 
   //

library/src/scala/tasty/Reflection.scala

@@ -27,14 +27,17 @@ 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)
+  object typing {
+   /** Whether the code type checks in the given context?
+    *
+    *  @param code The code to be type checked
+    *
+    *  @return false if the code has syntax error or type error in the given context, otherwise returns true.
+    *
+    *  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

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

@@ -3,13 +3,13 @@ import scala.tasty._
 
 object scalatest {
 
-  inline def assertCompiles(inline code: String): Unit = ${ assertImpl(code, true) }
+  inline def assertCompile(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)
+    val actual = typing.typeChecks(code)
 
     '{ assert(${expect.toExpr} == ${actual.toExpr}) }
   }

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

@@ -9,7 +9,32 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    assertCompiles("5 === 5")
+    assertCompile("5 === 5")
     assertNotCompile("5.6 === 7.7")
+
+    val x: Int = 5
+    assertCompile("x + 3")
+    assertNotCompile("y + 3")
+    import scala.util.Left
+    assertCompile("Left(3)")
+    assertNotCompile("Rigth(3)")
+
+    def f(x: Int): Int = x * x
+    assertCompile("f(3)")
+    assertNotCompile("g(3)")
+
+    type T
+    assertCompile("def foo(x: T): T = x")
+    assertNotCompile("foo(???)")
+    assertNotCompile("def foo(x: S): S = x")
+
+    assertNotCompile("def test(x: Int) =")
+
+    assertCompile(
+      """
+      class EqString extends Eq[String]
+      new EqString
+      """
+    )
   }
 }