Rework TastyInspector API to allow inspection of all files

Author: nicolasstucki

tasty-inspector/src/scala/tasty/inspector/Inspector.scala

@@ -0,0 +1,25 @@
+package scala.tasty.inspector
+
+import scala.quoted._
+import scala.quoted.runtime.impl.QuotesImpl
+
+import dotty.tools.dotc.Compiler
+import dotty.tools.dotc.Driver
+import dotty.tools.dotc.Run
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.fromtasty._
+import dotty.tools.dotc.util.ClasspathFromClassloader
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.unsupported
+import dotty.tools.dotc.report
+
+import java.io.File.pathSeparator
+
+trait Inspector:
+
+  /** Inspect all TASTy files using `Quotes` reflect API */
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit
+
+end Inspector

tasty-inspector/src/scala/tasty/inspector/TastyInspector.scala

@@ -17,36 +17,29 @@ import dotty.tools.dotc.report
 
 import java.io.File.pathSeparator
 
-trait TastyInspector:
-  self =>
-
-  /** Process a TASTy file using TASTy reflect */
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit
-
-  /** Called after all compilation units are processed */
-  protected def postProcess(using Quotes): Unit = ()
+object TastyInspector:
 
   /** Load and process TASTy files using TASTy reflect
    *
    *  @param tastyFiles List of paths of `.tasty` files
    */
-  def inspectTastyFiles(tastyFiles: List[String]): Boolean =
-    inspectAllTastyFiles(tastyFiles, Nil, Nil)
+  def inspectTastyFiles(tastyFiles: List[String])(inspector: Inspector): Boolean =
+    inspectAllTastyFiles(tastyFiles, Nil, Nil)(inspector)
 
   /** Load and process TASTy files in a `jar` file using TASTy reflect
    *
    *  @param jars Path of `.jar` file
    */
-  def inspectTastyFilesInJar(jar: String): Boolean =
-    inspectAllTastyFiles(Nil, List(jar), Nil)
+  def inspectTastyFilesInJar(jar: String)(inspector: Inspector): Boolean =
+    inspectAllTastyFiles(Nil, List(jar), Nil)(inspector)
 
   /** Load and process TASTy files using TASTy reflect
    *
    *  @param tastyFiles List of paths of `.tasty` files
    *  @param jars List of path of `.jar` files
    *  @param dependenciesClasspath Classpath with extra dependencies needed to load class in the `.tasty` files
    */
-  def inspectAllTastyFiles(tastyFiles: List[String], jars: List[String], dependenciesClasspath: List[String]): Boolean =
+  def inspectAllTastyFiles(tastyFiles: List[String], jars: List[String], dependenciesClasspath: List[String])(inspector: Inspector): Boolean =
     def checkFile(fileName: String, ext: String): Unit =
       val file = dotty.tools.io.Path(fileName)
       if file.extension != ext then
@@ -56,7 +49,7 @@ trait TastyInspector:
     tastyFiles.foreach(checkFile(_, "tasty"))
     jars.foreach(checkFile(_, "jar"))
     val files = tastyFiles ::: jars
-    files.nonEmpty && inspectFiles(dependenciesClasspath, files)
+    files.nonEmpty && inspectFiles(dependenciesClasspath, files)(inspector)
 
   /** Load and process TASTy files using TASTy reflect and provided context
    *
@@ -65,31 +58,27 @@ trait TastyInspector:
    *  @param classes List of paths of `.tasty` and `.jar` files (no validation is performed)
    *  @param classpath Classpath with extra dependencies needed to load class in the `.tasty` files
    */
-  protected[inspector] def inspectFilesInContext(classpath: List[String], classes: List[String])(using Context): Unit =
-    if (classes.isEmpty) report.error("Parameter classes should no be empty")
-    inspectorDriver().process(inspectorArgs(classpath, classes), summon[Context])
+  // protected[inspector] def inspectFilesInContext(classpath: List[String], classes: List[String])(using Context): Unit =
+  //   if (classes.isEmpty) report.error("Parameter classes should no be empty")
+  //   inspectorDriver(inspector).process(inspectorArgs(classpath, classes), summon[Context])
 
 
-  private def inspectorDriver() =
+  private def inspectorDriver(inspector: Inspector) =
     class InspectorDriver extends Driver:
       override protected def newCompiler(implicit ctx: Context): Compiler = new TastyFromClass
 
     class TastyInspectorPhase extends Phase:
       override def phaseName: String = "tastyInspector"
 
-      override def run(implicit ctx: Context): Unit =
-        val qctx = QuotesImpl()
-        self.processCompilationUnit(using qctx)(ctx.compilationUnit.tpdTree.asInstanceOf[qctx.reflect.Tree])
-
-    class TastyInspectorFinishPhase extends Phase:
-      override def phaseName: String = "tastyInspectorFinish"
-
       override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
-        val qctx = QuotesImpl()
-        self.postProcess(using qctx)
+        val quotesImpl = QuotesImpl()
+        val sources = units.map(unit => unit.source.path)
+        val trees = units.map(unit => unit.tpdTree.asInstanceOf[quotesImpl.reflect.Tree])
+        inspector.inspect(using quotesImpl)(sources, trees)
         units
 
       override def run(implicit ctx: Context): Unit = unsupported("run")
+    end TastyInspectorPhase
 
     class TastyFromClass extends TASTYCompiler:
 
@@ -103,7 +92,6 @@ trait TastyInspector:
 
       override protected def backendPhases: List[List[Phase]] =
         List(new TastyInspectorPhase) ::  // Perform a callback for each compilation unit
-        List(new TastyInspectorFinishPhase) :: // Perform a final callback
         Nil
 
       override def newRun(implicit ctx: Context): Run =
@@ -118,11 +106,11 @@ trait TastyInspector:
     ("-from-tasty" :: "-Yretain-trees" :: "-classpath" :: fullClasspath :: classes).toArray
 
 
-  private def inspectFiles(classpath: List[String], classes: List[String]): Boolean =
+  private def inspectFiles(classpath: List[String], classes: List[String])(inspector: Inspector): Boolean =
     if (classes.isEmpty)
       throw new IllegalArgumentException("Parameter classes should no be empty")
 
-    val reporter = inspectorDriver().process(inspectorArgs(classpath, classes))
+    val reporter = inspectorDriver(inspector).process(inspectorArgs(classpath, classes))
     reporter.hasErrors
 
   end inspectFiles

tests/run-custom-args/tasty-inspector/i10359.scala

@@ -29,18 +29,20 @@ object Test {
     val tastyFiles = allTastyFiles.filter(_.contains("TraitParams"))
 
     val inspect = new TestInspector()
-    inspect.inspectTastyFiles(allTastyFiles.filter(_.contains("Bar")))
+    TastyInspector.inspectTastyFiles(allTastyFiles.filter(_.contains("Bar")))(inspect)
   }
 }
 
-class TestInspector() extends TastyInspector:
+class TestInspector() extends Inspector:
 
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit =
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit = {
     import quotes.reflect._
 
-    val code = root.show
-    assert(code.contains("import Foo.this.g.{given}"), code)
-    assert(code.contains("import Foo.this.g.{given scala.Int}"), code)
+    for root <- trees do
+      val code = root.show
+      assert(code.contains("import Foo.this.g.{given}"), code)
+      assert(code.contains("import Foo.this.g.{given scala.Int}"), code)
 
-    val extractors = root.show(using Printer.TreeStructure)
-    assert(extractors.contains("GivenSelector"), extractors)
+      val extractors = root.show(using Printer.TreeStructure)
+      assert(extractors.contains("GivenSelector"), extractors)
+  }

tests/run-custom-args/tasty-inspector/i8163.scala

@@ -16,14 +16,15 @@ object Test {
     val allTastyFiles = dotty.tools.io.Path(classpath).walkFilter(_.extension == "tasty").map(_.toString).toList
     val tastyFiles = allTastyFiles.filter(_.contains("I8163"))
 
-    new TestInspector().inspectTastyFiles(tastyFiles)
+    TastyInspector.inspectTastyFiles(tastyFiles)(new TestInspector())
   }
 }
 
-class TestInspector() extends TastyInspector:
+class TestInspector() extends Inspector:
 
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit =
-    inspectClass(root)
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit =
+    for tree <- trees do
+      inspectClass(tree)
 
   private def inspectClass(using Quotes)(tree: quotes.reflect.Tree): Unit =
     import quotes.reflect._

tests/run-custom-args/tasty-inspector/i8364.scala

@@ -2,15 +2,16 @@ import scala.quoted._
 import scala.tasty.inspector._
 
 @main def Test = {
-  val inspector = new TastyInspector {
-    protected def processCompilationUnit(using Quotes)(tree: quotes.reflect.Tree): Unit = {
-      tree.show(using quotes.reflect.Printer.TreeStructure) // Make sure that tree is loaded and can be traveresed
+  val inspector = new Inspector {
+    def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit = {
+      for tree <- trees do
+        tree.show(using quotes.reflect.Printer.TreeStructure) // Make sure that tree is loaded and can be traveresed
     }
   }
 
    // Artefact of the current test infrastructure
   // TODO improve infrastructure to avoid needing this code on each test
   val libJarClasspath = dotty.tools.dotc.util.ClasspathFromClassloader(this.getClass.getClassLoader).split(java.io.File.pathSeparator).find(x => x.contains("scala3-library-bootstrapped") && x.endsWith(".jar")).get
 
-  inspector.inspectTastyFilesInJar(libJarClasspath)
+  TastyInspector.inspectTastyFilesInJar(libJarClasspath)(inspector)
 }

tests/run-custom-args/tasty-inspector/i8389.scala

@@ -9,12 +9,13 @@ import scala.tasty.inspector._
   val tastyFiles = allTastyFiles.filter(_.contains("TraitParams"))
 
   // in dotty-example-project
-  val inspector = new TastyInspector {
-    protected def processCompilationUnit(using Quotes)(tree: quotes.reflect.Tree): Unit = {
-      println(tree.show)
+  val inspector = new Inspector {
+    def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit = {
+      for tree <- trees do
+        println(tree.show)
     }
   }
-  inspector.inspectTastyFiles(tastyFiles)
+  TastyInspector.inspectTastyFiles(tastyFiles)(inspector)
 }
 
 object TraitParams {

tests/run-custom-args/tasty-inspector/i8460.scala

@@ -23,23 +23,25 @@ object Test {
 
     // Tasty Scala Class
     val inspect1 = new TestInspector_Children()
-    inspect1.inspectTastyFiles(allTastyFiles.filter(_.contains("Vehicle")))
+    TastyInspector.inspectTastyFiles(allTastyFiles.filter(_.contains("Vehicle")))(inspect1)
     assert(inspect1.kids == List("Truck","Car","Plane"))
 
     // Java Class
     val inspect2 = new TestInspector_Children()
-    inspect2.inspectTastyFiles(allTastyFiles.filter(_.contains("Flavor")))
+    TastyInspector.inspectTastyFiles(allTastyFiles.filter(_.contains("Flavor")))(inspect2)
     assert(inspect2.kids == List("Vanilla","Chocolate","Bourbon"))
   }
 }
 
-class TestInspector_Children() extends TastyInspector:
+class TestInspector_Children() extends Inspector:
 
   var kids: List[String] = Nil
 
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit =
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit = {
     import quotes.reflect._
-    inspectClass(root)
+    for tree <- trees do
+      inspectClass(tree)
+  }
 
   private def inspectClass(using Quotes)(tree: quotes.reflect.Tree): Unit =
     import quotes.reflect._

tests/run-custom-args/tasty-inspector/i9970.scala

@@ -40,50 +40,52 @@ object Test {
     val allTastyFiles = dotty.tools.io.Path(classpath).walkFilter(_.extension == "tasty").map(_.toString).toList
     val tastyFiles = allTastyFiles.filter(_.contains("I9970"))
 
-    new TestInspector().inspectTastyFiles(tastyFiles)
+    TastyInspector.inspectTastyFiles(tastyFiles)(new TestInspector())
   }
 }
 
 // Inspector that performs the actual tests
 
-class TestInspector() extends TastyInspector:
-
-  private var foundIOApp: Boolean = false
-  private var foundSimple: Boolean = false
-
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit =
-    foundIOApp = false
-    foundSimple = false
-    inspectClass(root)
-    // Sanity check to make sure that our pattern matches are not simply glossing over the things we want to test
-    assert(foundIOApp, "the inspector did not encounter IOApp")
-    assert(foundSimple, "the inspect did not encounter IOApp.Simple")
-
-  private def inspectClass(using Quotes)(tree: quotes.reflect.Tree): Unit =
-    import quotes.reflect._
-    tree match
-      case t: PackageClause =>
-        t.stats.foreach(inspectClass(_))
-
-      case t: ClassDef if t.name.endsWith("$") =>
-        t.body.foreach(inspectClass(_))
-
-      case t: ClassDef =>
-        t.name match
-          case "I9970IOApp" =>
-            foundIOApp = true
-            // Cannot test the following because NoInits is not part of the quotes API
-            //assert(!t.symbol.flags.is(Flags.NoInits))
-            assert(!t.constructor.symbol.flags.is(Flags.StableRealizable))
-
-          case "Simple" =>
-            foundSimple = true
-            // Cannot test the following because NoInits is not part of the quotes API
-            //assert(t.symbol.flags.is(Flags.NoInits))
-            assert(t.constructor.symbol.flags.is(Flags.StableRealizable))
-
-          case _ =>
-            assert(false, s"unexpected ClassDef '${t.name}'")
-
-      case _ =>
-  end inspectClass
+class TestInspector() extends Inspector:
+
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit =
+    var foundIOApp: Boolean = false
+    var foundSimple: Boolean = false
+
+    def inspectClass(using Quotes)(tree: quotes.reflect.Tree): Unit =
+      import quotes.reflect._
+      tree match
+        case t: PackageClause =>
+          t.stats.foreach(inspectClass(_))
+
+        case t: ClassDef if t.name.endsWith("$") =>
+          t.body.foreach(inspectClass(_))
+
+        case t: ClassDef =>
+          t.name match
+            case "I9970IOApp" =>
+              foundIOApp = true
+              // Cannot test the following because NoInits is not part of the quotes API
+              //assert(!t.symbol.flags.is(Flags.NoInits))
+              assert(!t.constructor.symbol.flags.is(Flags.StableRealizable))
+
+            case "Simple" =>
+              foundSimple = true
+              // Cannot test the following because NoInits is not part of the quotes API
+              //assert(t.symbol.flags.is(Flags.NoInits))
+              assert(t.constructor.symbol.flags.is(Flags.StableRealizable))
+
+            case _ =>
+              assert(false, s"unexpected ClassDef '${t.name}'")
+
+        case _ =>
+
+    for tree <- trees do
+      foundIOApp = false
+      foundSimple = false
+      inspectClass(tree)
+      // Sanity check to make sure that our pattern matches are not simply glossing over the things we want to test
+      assert(foundIOApp, "the inspector did not encounter IOApp")
+      assert(foundSimple, "the inspect did not encounter IOApp.Simple")
+
+  end inspect

tests/run-custom-args/tasty-inspector/tasty-documentation-inspector/Test.scala

@@ -9,13 +9,14 @@ object Test {
     val allTastyFiles = dotty.tools.io.Path(classpath).walkFilter(_.extension == "tasty").map(_.toString).toList
     val tastyFiles = allTastyFiles.filter(_.contains("Foo"))
 
-    new DocumentationInspector().inspectTastyFiles(tastyFiles)
+    TastyInspector.inspectTastyFiles(tastyFiles)(new DocumentationInspector())
   }
 }
 
-class DocumentationInspector extends TastyInspector {
+class DocumentationInspector extends Inspector {
+
+  def inspect(using Quotes)(sources: List[String], trees: List[quotes.reflect.Tree]): Unit = {
 
-  protected def processCompilationUnit(using Quotes)(root: quotes.reflect.Tree): Unit = {
     import quotes.reflect._
     object Traverser extends TreeTraverser {
 
@@ -31,7 +32,8 @@ class DocumentationInspector extends TastyInspector {
       }
 
     }
-    Traverser.traverseTree(root)
+    for tree <- trees do
+      Traverser.traverseTree(tree)
   }
 
 }