Internals for the typechecker for testing

Author: anatoliykmetyuk

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -868,6 +868,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToArgs(args: List[Tree])(implicit ctx: Context): Apply =
       Apply(tree, args)
 
+    /** An applied node that accepts only varargs as arguments */
+    def appliedToVarargs(args: List[Tree], tpt: Tree)(given Context): Tree =
+      appliedTo(repeated(args, tpt))
+
     /** The current tree applied to given argument lists:
      *  `tree (argss(0)) ... (argss(argss.length -1))`
      */
@@ -881,6 +885,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToType(targ: Type)(implicit ctx: Context): Tree =
       appliedToTypes(targ :: Nil)
 
+    /** The current tree applied to given type argument: `tree[targ]` */
+    def appliedToTypeTree(targ: Tree)(implicit ctx: Context): Tree =
+      appliedToTypeTrees(targ :: Nil)
+
     /** The current tree applied to given type arguments: `tree[targ0, ..., targN]` */
     def appliedToTypes(targs: List[Type])(implicit ctx: Context): Tree =
       appliedToTypeTrees(targs map (TypeTree(_)))
@@ -1357,5 +1365,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = atp.argTypes
     tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
   }
+
+  /** Convert a list of trees to a vararg-compatible tree.
+   *  Used to make arguments for methods that accept varargs.
+   */
+  def repeated(trees: List[Tree], tpt: Tree)(given ctx: Context): Tree =
+    ctx.typeAssigner.arrayToRepeated(JavaSeqLiteral(trees, tpt))
 }
 

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -225,7 +225,14 @@ class Definitions {
     @tu lazy val Compiletime_code         : Symbol = CompiletimePackageObject.requiredMethod("code")
     @tu lazy val Compiletime_summonFrom   : Symbol = CompiletimePackageObject.requiredMethod("summonFrom")
   @tu lazy val CompiletimeTestingPackageObject: Symbol = ctx.requiredModule("scala.compiletime.testing.package")
-    @tu lazy val CompiletimeTesting_typeChecks   : Symbol = CompiletimeTestingPackageObject.requiredMethod("typeChecks")
+    @tu lazy val CompiletimeTesting_typeChecks: Symbol = CompiletimeTestingPackageObject.requiredMethod("typeChecks")
+    @tu lazy val CompiletimeTesting_typeCheckErrors: Symbol = CompiletimeTestingPackageObject.requiredMethod("typeCheckErrors")
+    @tu lazy val CompiletimeTesting_ErrorClass: ClassSymbol = ctx.requiredClass("scala.compiletime.testing.Error")
+    @tu lazy val CompiletimeTesting_Error: Symbol = ctx.requiredModule("scala.compiletime.testing.Error")
+      @tu lazy val CompiletimeTesting_Error_apply = CompiletimeTesting_Error.requiredMethod(nme.apply)
+    @tu lazy val CompiletimeTesting_ErrorKind: Symbol = ctx.requiredModule("scala.compiletime.testing.ErrorKind")
+      @tu lazy val CompiletimeTesting_ErrorKind_Parser: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Parser")
+      @tu lazy val CompiletimeTesting_ErrorKind_Typer: Symbol = CompiletimeTesting_ErrorKind.requiredMethod("Typer")
 
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will
@@ -389,6 +396,8 @@ class Definitions {
     methodNames.map(getWrapVarargsArrayModule.requiredMethod(_))
   })
 
+  @tu lazy val ListClass: ClassSymbol = ctx.requiredClass("scala.collection.immutable.List")
+  @tu lazy val ListModule: Symbol = ListClass.companionModule
   @tu lazy val NilModule: Symbol = ctx.requiredModule("scala.collection.immutable.Nil")
 
   @tu lazy val SingletonClass: ClassSymbol =

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -67,6 +67,7 @@ object Inliner {
    */
   def inlineCall(tree: Tree)(implicit ctx: Context): Tree = {
     if (tree.symbol == defn.CompiletimeTesting_typeChecks) return Intrinsics.typeChecks(tree)
+    if (tree.symbol == defn.CompiletimeTesting_typeCheckErrors) return Intrinsics.typeCheckErrors(tree)
 
    /** Set the position of all trees logically contained in the expansion of
     *  inlined call `call` to the position of `call`. This transform is necessary
@@ -193,10 +194,12 @@ object Inliner {
   }
 
   object Intrinsics {
+    import dotty.tools.dotc.reporting.diagnostic.messages.Error
+    private enum ErrorKind
+      case Parser, Typer
 
-    /** Expand call to scala.compiletime.testing.typeChecks */
-    def typeChecks(tree: Tree)(implicit ctx: Context): Tree = {
-      assert(tree.symbol == defn.CompiletimeTesting_typeChecks)
+    private def compileForErrors(tree: Tree, stopAfterParser: Boolean)(given ctx: Context): List[(ErrorKind, Error)] =
+      assert(tree.symbol == defn.CompiletimeTesting_typeChecks || tree.symbol == defn.CompiletimeTesting_typeCheckErrors)
       def stripTyped(t: Tree): Tree = t match {
         case Typed(t2, _) => stripTyped(t2)
         case _ => t
@@ -205,20 +208,49 @@ object Inliner {
       val Apply(_, codeArg :: Nil) = tree
       ConstFold(stripTyped(codeArg.underlyingArgument)).tpe.widenTermRefExpr match {
         case ConstantType(Constant(code: String)) =>
-          val ctx2 = ctx.fresh.setNewTyperState().setTyper(new Typer)
-          val tree2 = new Parser(SourceFile.virtual("tasty-reflect", code))(ctx2).block()
-          val res =
-            if (ctx2.reporter.hasErrors) false
-            else {
-              ctx2.typer.typed(tree2)(ctx2)
-              !ctx2.reporter.hasErrors
-            }
-          Literal(Constant(res))
+          val source2 = SourceFile.virtual("tasty-reflect", code)
+          val ctx2 = ctx.fresh.setNewTyperState().setTyper(new Typer).setSource(source2)
+          val tree2 = new Parser(source2)(ctx2).block()
+          val res = collection.mutable.ListBuffer.empty[(ErrorKind, Error)]
+
+          val parseErrors = ctx2.reporter.allErrors.toList
+          res ++= parseErrors.map(e => ErrorKind.Parser -> e)
+          if !stopAfterParser || res.isEmpty
+            ctx2.typer.typed(tree2)(ctx2)
+            val typerErrors = ctx2.reporter.allErrors.filterNot(parseErrors.contains)
+            res ++= typerErrors.map(e => ErrorKind.Typer -> e)
+          res.toList
         case t =>
           assert(ctx.reporter.hasErrors) // at least: argument to inline parameter must be a known value
-          EmptyTree
+          Nil
       }
-    }
+
+    private def packError(kind: ErrorKind, error: Error)(given Context): Tree =
+      def lit(x: Any) = Literal(Constant(x))
+      val constructor: Tree = ref(defn.CompiletimeTesting_Error_apply)
+      val parserErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Parser)
+      val typerErrorKind: Tree = ref(defn.CompiletimeTesting_ErrorKind_Typer)
+
+      constructor.appliedTo(
+        lit(error.message), lit(error.pos.lineContent), lit(error.pos.column),
+        if kind == ErrorKind.Parser then parserErrorKind else typerErrorKind)
+
+    private def packErrors(errors: List[(ErrorKind, Error)])(given Context): Tree =
+      val individualErrors: List[Tree] = errors.map(packError)
+      val errorTpt = ref(defn.CompiletimeTesting_ErrorClass)
+      ref(defn.ListModule).select(nme.apply)
+        .appliedToTypeTree(errorTpt)
+        .appliedToVarargs(individualErrors, errorTpt)
+
+    /** Expand call to scala.compiletime.testing.typeChecks */
+    def typeChecks(tree: Tree)(given Context): Tree =
+      val errors = compileForErrors(tree, true)
+      Literal(Constant(errors.isEmpty))
+
+    /** Expand call to scala.compiletime.testing.typeCheckErrors */
+    def typeCheckErrors(tree: Tree)(given Context): Tree =
+      val errors = compileForErrors(tree, false)
+      packErrors(errors)
   }
 }
 

library/src/scala/compiletime/testing/package.scala

@@ -4,21 +4,23 @@ import scala.quoted._
 
 package object testing {
 
+  /** Represents a compile-time error */
   case class Error(message: String, lineContent: String, column: Int, kind: ErrorKind)
   object Error
     given Liftable[Error]
       def toExpr(e: Error) =
         '{Error(${Expr(e.message)}, ${Expr(e.lineContent)}, ${Expr(e.column)}, ${Expr(e.kind)})}
 
+  /** An error can be either a parse-time or a typecheck-time */
   enum ErrorKind
-    case Parse, Compile
+    case Parser, Typer
 
   object ErrorKind
     given Liftable[ErrorKind]
       import ErrorKind._
       def toExpr(e: ErrorKind) = e match
-        case Parse => '{Parse}
-        case Compile => '{Compile}
+        case Parser => '{Parser}
+        case Typer => '{Typer}
 
   /** Whether the code type checks in the current context?
    *
@@ -31,4 +33,14 @@ package object testing {
   inline def typeChecks(inline code: String): Boolean =
     error("`typeChecks` was not checked by the compiler")
 
+  /** Whether the code type checks in the current context?
+   *
+   *  @param code The code to be type checked
+   *
+   *  @return a list of errors encountered during parsing and typechecking.
+   *
+   *  The code should be a sequence of expressions or statements that may appear in a block.
+   */
+  inline def typeCheckErrors(inline code: String): List[Error] =
+    error("`typeCheckErrors` was not checked by the compiler")
 }