Fix issue with certain synthetics missing in compiletime.typechecks

Previously, instead of using the PostTyper phase directly, a typed tree
Transformer was used. However, it did not transform the ClassInfo
values using PostTyper.transformInfo, which lead to RefChecks not
finding certain synthesized methods, throwing an incorrect error about
a missing implementation. This is fixed by running the full suite of
PostTyper transforms. A minor refactor is included, to limit
the repeated CompilationUnit construction and error checking.

[Cherry-picked 8f48a3b]

Author: jchyb

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -134,7 +134,7 @@ object CompilationUnit {
   /** Create a compilation unit corresponding to an in-memory String.
    *  Used for `compiletime.testing.typeChecks`.
    */
-  def apply(name: String, source: String)(using Context): CompilationUnit = {
+  def apply(name: String, source: String): CompilationUnit = {
     val src = SourceFile.virtual(name = name, content = source, maybeIncomplete = false)
     new CompilationUnit(src)
   }

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -393,38 +393,42 @@ object Inlines:
         case ConstantType(Constant(code: String)) =>
           val unitName = "tasty-reflect"
           val source2 = SourceFile.virtual(unitName, code)
+          def compilationUnits(untpdTree: untpd.Tree, tpdTree: Tree): List[CompilationUnit] =
+            val compilationUnit = CompilationUnit(unitName, code)
+            compilationUnit.tpdTree = tpdTree
+            compilationUnit.untpdTree = untpdTree
+            List(compilationUnit)
           // We need a dummy owner, as the actual one does not have a computed denotation yet,
           // but might be inspected in a transform phase, leading to cyclic errors
           val dummyOwner = newSymbol(ctx.owner, "$dummySymbol$".toTermName, Private, defn.AnyType, NoSymbol)
           val newContext =
             ctx.fresh.setNewTyperState().setTyper(new Typer(ctx.nestingLevel + 1)).setSource(source2)
 
           inContext(newContext) {
-            val tree2 = new Parser(source2).block()
-            if ctx.reporter.allErrors.nonEmpty then
+            def noErrors = ctx.reporter.allErrors.isEmpty
+            val untpdTree = new Parser(source2).block()
+            if !noErrors then
               ctx.reporter.allErrors.map((ErrorKind.Parser, _))
             else
-              val tree3 = ctx.typer.typed(tree2)
+              val tpdTree1 = ctx.typer.typed(untpdTree)
               ctx.base.postTyperPhase match
-                case postTyper: PostTyper if ctx.reporter.allErrors.isEmpty =>
-                  val tree4 = atPhase(postTyper) { postTyper.newTransformer.transform(tree3) }
+                case postTyper: PostTyper if noErrors =>
+                  val tpdTree2 =
+                    atPhase(postTyper) { postTyper.runOn(compilationUnits(untpdTree, tpdTree1)).head.tpdTree }
                   ctx.base.setRootTreePhase match
-                    case setRootTree =>
-                      val tree5 =
-                        val compilationUnit = CompilationUnit(unitName, code)
-                        compilationUnit.tpdTree = tree4
-                        compilationUnit.untpdTree = tree2
-                        var units = List(compilationUnit)
-                        atPhase(setRootTree)(setRootTree.runOn(units).head.tpdTree)
+                    case setRootTree if noErrors => // might be noPhase, if -Yretain-trees is not used
+                      val tpdTree3 =
+                        atPhase(setRootTree)(setRootTree.runOn(compilationUnits(untpdTree, tpdTree2)).head.tpdTree)
                       ctx.base.inliningPhase match
-                        case inlining: Inlining if ctx.reporter.allErrors.isEmpty =>
-                          val tree6 = atPhase(inlining) { inlining.newTransformer.transform(tree5) }
-                          if ctx.reporter.allErrors.isEmpty && reconstructedTransformPhases.nonEmpty then
-                            var transformTree = tree6
+                        case inlining: Inlining if noErrors =>
+                          val tpdTree4 = atPhase(inlining) { inlining.newTransformer.transform(tpdTree3) }
+                          if noErrors && reconstructedTransformPhases.nonEmpty then
+                            var transformTree = tpdTree4
                             for phase <- reconstructedTransformPhases do
-                              if ctx.reporter.allErrors.isEmpty then
+                              if noErrors then
                                 transformTree = atPhase(phase.end + 1)(phase.transformUnit(transformTree))
                         case _ =>
+                    case _ =>
                 case _ =>
               ctx.reporter.allErrors.map((ErrorKind.Typer, _))
           }

compiler/test/dotc/run-test-pickling.excludelist

@@ -49,4 +49,4 @@ named-tuples-strawman-2.scala
 # typecheckErrors method unpickling
 typeCheckErrors.scala
 i18150.scala
-
+i22968.scala

tests/run/i22968.check

@@ -0,0 +1 @@
+List()

tests/run/i22968.scala

@@ -0,0 +1,7 @@
+import scala.compiletime.testing.typeCheckErrors
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    println(typeCheckErrors("enum Foo { case A }"))
+  }
+}