Create infrastructure for semantic db

tests/run-with-compiler/tasty-consumer/Test.scala shows an example of how
to consume tasty files.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/consumetasty/ConsumeTasty.scala

@@ -0,0 +1,22 @@
+package dotty.tools.dotc.consumetasty
+
+import dotty.tools.dotc
+import dotty.tools.dotc.core.Contexts._
+
+import scala.tasty.file.TastyConsumer
+
+object ConsumeTasty {
+  def apply(classpath: String, classes: List[String], tastyConsumer: TastyConsumer): Unit = {
+    if (classes.isEmpty)
+      throw new IllegalArgumentException("Parameter classes should no be empty")
+
+    class Consume extends dotc.Driver {
+      override protected def newCompiler(implicit ctx: Context): dotc.Compiler =
+        new TastyFromClass(tastyConsumer)
+    }
+
+    val currentClasspath = System.getProperty("java.class.path")
+    val args = "-from-tasty" +: "-classpath" +: s"$classpath:$currentClasspath" +: classes
+    (new Consume).process(args.toArray)
+  }
+}

compiler/src/dotty/tools/dotc/consumetasty/TastyConsumerPhase.scala

@@ -0,0 +1,18 @@
+package dotty.tools.dotc.consumetasty
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.tastyreflect.TastyImpl
+
+import scala.tasty.file.TastyConsumer
+
+class TastyConsumerPhase(consumer: TastyConsumer) extends Phase {
+
+  override def phaseName: String = "tastyConsumer"
+
+  override def run(implicit ctx: Context): Unit = {
+    val tasty = new TastyImpl(ctx)
+    consumer(tasty)(ctx.compilationUnit.tpdTree)
+  }
+
+}

compiler/src/dotty/tools/dotc/consumetasty/TastyFromClass.scala

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.consumetasty
+
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.fromtasty._
+
+import scala.tasty.file.TastyConsumer
+
+class TastyFromClass(consumer: TastyConsumer) extends TASTYCompiler {
+
+  override protected def frontendPhases: List[List[Phase]] =
+    List(new ReadTastyTreesFromClasses) :: // Load classes from tasty
+    Nil
+
+  override protected def picklerPhases: List[List[Phase]] = Nil
+  override protected def transformPhases: List[List[Phase]] = Nil
+
+  override protected def backendPhases: List[List[Phase]] =
+    List(new TastyConsumerPhase(consumer)) ::  // Print all loaded classes
+    Nil
+}

library/src/scala/tasty/file/ConsumeTasty.scala

@@ -0,0 +1,19 @@
+package scala.tasty.file
+
+object ConsumeTasty {
+  def apply(classpath: String, classes: List[String], tastyConsumer: TastyConsumer): Unit = {
+    val cl = getClass.getClassLoader
+    try {
+      val dottyConsumeTastyCls = cl.loadClass("dotty.tools.dotc.consumetasty.ConsumeTasty")
+      val makeMeth = dottyConsumeTastyCls.getMethod("apply", classOf[String], classOf[List[_]], classOf[TastyConsumer])
+      makeMeth.invoke(null, classpath, classes, tastyConsumer)
+    }
+    catch {
+      case ex: ClassNotFoundException =>
+        throw new Exception(
+          s"""Could not load the dotty.tools.dotc.consumetasty.ConsumeTasty class `${ex.getMessage}` from the JVM classpath. Make sure that the compiler is on the JVM classpath.""",
+          ex
+        )
+    }
+  }
+}

library/src/scala/tasty/file/TastyConsumer.scala

@@ -0,0 +1,7 @@
+package scala.tasty.file
+
+import scala.tasty.Tasty
+
+trait TastyConsumer {
+  def apply(tasty: Tasty)(root: tasty.Tree): Unit
+}

project/Build.scala

@@ -677,6 +677,7 @@ object Build {
     val dottyCompiler = jars("dotty-compiler")
     val args0: List[String] = spaceDelimited("<arg>").parsed.toList
     val decompile = args0.contains("-decompile")
+    val consumeTasty = args0.contains("-gen-semantic-db")
     val printTasty = args0.contains("-print-tasty")
     val debugFromTasty = args0.contains("-Ythrough-tasty")
     val args = args0.filter(arg => arg != "-repl" && arg != "-decompile" &&
@@ -685,11 +686,12 @@ object Build {
     val main =
       if (repl) "dotty.tools.repl.Main"
       else if (decompile || printTasty) "dotty.tools.dotc.decompiler.Main"
+      else if (consumeTasty) "dotty.tools.dotc.semanticdb.Main"
       else if (debugFromTasty) "dotty.tools.dotc.fromtasty.Debug"
       else "dotty.tools.dotc.Main"
 
     var extraClasspath = s"$scalaLib${File.pathSeparator}$dottyLib"
-    if ((decompile || printTasty) && !args.contains("-classpath")) extraClasspath += s"${File.pathSeparator}."
+    if ((decompile || printTasty || consumeTasty) && !args.contains("-classpath")) extraClasspath += s"${File.pathSeparator}."
     if (args0.contains("-with-compiler")) {
       if (!isDotty.value) {
         throw new MessageOnlyException("-with-compiler can only be used with a bootstrapped compiler")

tests/run-with-compiler/tasty-consumer.check

@@ -0,0 +1,5 @@
+ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("foo", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(2)))), DefDef("bar", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))))
+DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None)
+ValDef("foo", TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(2))))
+DefDef("bar", Nil, List(List(ValDef("i", TypeTree.TypeIdent("Int"), None))), TypeTree.TypeIdent("Int"), Some(Term.Literal(Constant.Int(3))))
+ValDef("i", TypeTree.TypeIdent("Int"), None)

tests/run-with-compiler/tasty-consumer/Foo.scala

@@ -0,0 +1,5 @@
+
+class Foo {
+  val foo: Int = 2
+  def bar(i: Int): Int = 3
+}

tests/run-with-compiler/tasty-consumer/Test.scala

@@ -0,0 +1,29 @@
+import scala.tasty.Tasty
+import scala.tasty.util.TreeTraverser
+import scala.tasty.file._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    ConsumeTasty("", List("Foo"), new DBConsumer)
+  }
+}
+
+class DBConsumer extends TastyConsumer {
+
+  final def apply(tasty: Tasty)(root: tasty.Tree): Unit = {
+    import tasty._
+    object Traverser extends TreeTraverser[tasty.type](tasty) {
+
+      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = tree match {
+        case IsDefinition(tree) =>
+          println(tree.show)
+          super.traverseTree(tree)
+        case tree =>
+          super.traverseTree(tree)
+      }
+
+    }
+    Traverser.traverseTree(root)(tasty.rootContext)
+  }
+
+}