Remove the makefile and refactored the testsuite

- the testsuite now builds a map sourcefile -> tastyfile, thus allowing
a test to possess several class in the same source code

Author: poechsel

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -104,6 +104,7 @@ trait TreeUtils
       case TypeTree.Block(typedefs, tpt) => foldTypeTree(foldTrees(x, typedefs), tpt)
       case TypeTree.MatchType(boundopt, selector, cases) =>
         foldTypeCaseDefs(foldTypeTree(boundopt.fold(x)(foldTypeTree(x, _)), selector), cases)
+      case SyntheticBounds() => x
       case TypeBoundsTree(lo, hi) => foldTypeTree(foldTypeTree(x, lo), hi)
     }
 

project/Build.scala

@@ -393,12 +393,9 @@ object Build {
     baseDirectory in Test := baseDirectory.value / "..",
     unmanagedSourceDirectories in Test += baseDirectory.value / "input" / "src" / "main" / "scala",
     libraryDependencies ++= List(
-      ("org.scalameta" %% "semanticdb" % "4.0.0" % Compile).withDottyCompat(scalaVersion.value),
-      "com.novocode" % "junit-interface" % "0.11" % Compile,
-      "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0" % Compile,
-      ("org.scalameta" %% "semanticdb" % "4.0.0" % Test).withDottyCompat(scalaVersion.value),
-      "com.novocode" % "junit-interface" % "0.11" % Test,
-      "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0" % Test
+      ("org.scalameta" %% "semanticdb" % "4.0.0").withDottyCompat(scalaVersion.value),
+      "com.novocode" % "junit-interface" % "0.11",
+      "com.googlecode.java-diff-utils" % "diffutils" % "1.3.0"
     )
   )
 

semanticdb/Makefile

@@ -14,4 +14,8 @@ class Example {
       x +
       y
     )
+}
+
+class ExampleInit() {
+
 }

semanticdb/input/src/main/scala/example/Example.scala

@@ -10,14 +10,6 @@ sbt
 > compile
 ```
 
-You will also need to generate the tasty files for the test. For now, you can
-easily do it by executing the makefile in this folder:
-```
-make
-```
-Please note that the makefile will also compile the `semanticdb/input` project.
-
-
 In the second terminal, run `sbt dotty-semanticdb/test` from the main dotty
 build
 

semanticdb/readme.md

@@ -5,6 +5,7 @@ import scala.tasty.file.TastyConsumer
 
 import dotty.tools.dotc.tastyreflect
 import scala.collection.mutable.HashMap
+import scala.collection.mutable.Set
 import scala.meta.internal.{semanticdb => s}
 import dotty.semanticdb.Scala.{Descriptor => d}
 import dotty.semanticdb.Scala._
@@ -18,16 +19,25 @@ class SemanticdbConsumer extends TastyConsumer {
   def toSemanticdb(text: String): s.TextDocument = {
     s.TextDocument(text = text, occurrences = occurrences)
   }
+  val package_definitions: Set[String] = Set()
 
   final def apply(reflect: Reflection)(root: reflect.Tree): Unit = {
     import reflect._
 
+    val symbolsCache: HashMap[Symbol, String] = HashMap()
+
     object ChildTraverser extends TreeTraverser {
       var children: List[Tree] = Nil
-      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = children = tree::children
-      override def traversePattern(pattern: Pattern)(implicit ctx: Context): Unit = ()
-      override def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = ()
-      override def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = ()
+      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit =
+        children = tree :: children
+      override def traversePattern(pattern: Pattern)(
+          implicit ctx: Context): Unit = ()
+      override def traverseTypeTree(tree: TypeOrBoundsTree)(
+          implicit ctx: Context): Unit = ()
+      override def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit =
+        ()
+      override def traverseTypeCaseDef(tree: TypeCaseDef)(implicit ctx: Context): Unit =
+        ()
 
       def getChildren(tree: Tree)(implicit ctx: Context): List[Tree] = {
         children = Nil
@@ -37,7 +47,6 @@ class SemanticdbConsumer extends TastyConsumer {
     }
 
     object Traverser extends TreeTraverser {
-      val symbolsCache: HashMap[Symbol, String] = HashMap()
       implicit class TreeExtender(tree: Tree) {
         def isUserCreated: Boolean = {
           val children: List[Position] =
@@ -86,21 +95,21 @@ class SemanticdbConsumer extends TastyConsumer {
 
       def resolveClass(symbol: ClassSymbol): Symbol =
         (symbol.companionClass, symbol.companionModule) match {
-            case (_, Some(module)) if symbol.flags.isObject => module
-            case (Some(c), _) => c
-            case _ => symbol
+          case (_, Some(module)) if symbol.flags.isObject => module
+          case (Some(c), _)                               => c
+          case _                                          => symbol
         }
 
       def disimbiguate(symbol_path: String, symbol: Symbol): String = {
         val symbolcl = resolveClass(symbol.owner.asClass)
         val methods = symbolcl.asClass.method(symbol.name)
         val (methods_count, method_pos) =
-          methods.foldLeft((0, -1))((x:Tuple2[Int, Int], m:Symbol) => {
+          methods.foldLeft((0, -1))((x: Tuple2[Int, Int], m: Symbol) => {
             if (m == symbol)
-              (x._1+1, x._1)
-             else
-             (x._1+1, x._2)
-            })
+              (x._1 + 1, x._1)
+            else
+              (x._1 + 1, x._2)
+          })
         val real_pos = methods_count - method_pos - 1
 
         if (real_pos == 0) {
@@ -262,9 +271,12 @@ class SemanticdbConsumer extends TastyConsumer {
             super.traverseTree(tree)
           }
           case PackageClause(_) =>
-            addOccurenceTree(tree,
-                             s.SymbolOccurrence.Role.REFERENCE,
-                             range(tree, tree.pos, tree.symbol.name))
+            if (!package_definitions(tree.symbol.name)) {
+              addOccurenceTree(tree,
+                               s.SymbolOccurrence.Role.REFERENCE,
+                               range(tree, tree.pos, tree.symbol.name))
+              package_definitions += tree.symbol.name
+            }
             super.traverseTree(tree)
 
           case tree =>

semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala

@@ -2,42 +2,138 @@ package dotty.semanticdb
 
 import scala.tasty.Reflection
 import scala.tasty.file._
+import scala.collection.mutable.HashMap
 
 import org.junit.Test
 import org.junit.Assert._
 import java.nio.file._
 import scala.meta.internal.{semanticdb => s}
 import scala.collection.JavaConverters._
+import java.io.File
+import scala.tasty.Reflection
+import scala.tasty.file.TastyConsumer
+import java.lang.reflect.InvocationTargetException
+
+class TastyInspecter extends TastyConsumer {
+  var source_path: Option[String] = None
+  final def apply(reflect: Reflection)(root: reflect.Tree): Unit = {
+    import reflect._
+    object ChildTraverser extends TreeTraverser {
+      override def traverseTree(tree: Tree)(implicit ctx: Context): Unit =
+        tree match {
+          case IsClassDef(cdef) => {
+            cdef.symbol.annots.foreach { annot =>
+              annot match {
+                case Term.Apply(Term.Select(Term.New(t), _, _),
+                                List(Term.Literal(Constant.String(path))))
+                    if t.symbol.name == "SourceFile" =>
+                  // we found the path to a file. In this case, we do not need to
+                  // continue traversing the tree
+                  source_path = Some(path)
+                case x => super.traverseTree(tree)
+              }
+              true
+            }
+          }
+          case _ => {
+            if (source_path == None)
+              super.traverseTree(tree)
+            else
+              ()
+          }
+        }
+    }
+    ChildTraverser.traverseTree(root)(reflect.rootContext)
+  }
+}
 
 class Tests {
 
   // TODO: update scala-0.10 on version change (or resolve automatically)
-  final def tastyClassDirectory = "out/bootstrap/dotty-semanticdb/scala-0.11/test-classes"
+  final def tastyClassDirectory =
+    "out/bootstrap/dotty-semanticdb/scala-0.11/test-classes"
   val sourceroot = Paths.get("semanticdb", "input").toAbsolutePath
   val sourceDirectory = sourceroot.resolve("src/main/scala")
 
   val semanticdbClassDirectory = sourceroot.resolve("target/scala-2.12/classes")
-  val semanticdbLoader = new Semanticdbs.Loader(sourceroot, List(semanticdbClassDirectory))
+  val semanticdbLoader =
+    new Semanticdbs.Loader(sourceroot, List(semanticdbClassDirectory))
+
+  val source_to_tasty =
+    getTastyFiles(
+      Paths.get("out", "bootstrap", "dotty-semanticdb/").toAbsolutePath)
+
   /** Returns the SemanticDB for this Scala source file. */
   def getScalacSemanticdb(scalaFile: Path): s.TextDocument = {
     semanticdbLoader.resolve(scalaFile).get
   }
 
-  /** TODO: Produce semanticdb from TASTy for this Scala source file. */
-  def getTastySemanticdb(scalaFile: Path): s.TextDocument = {
-    val scalac = getScalacSemanticdb(scalaFile)
-    val pat = """(.*)\.scala""".r
-    val classpath = scalaFile.getParent().toString()
-    val modulename = sourceDirectory.relativize(scalaFile).getParent().getFileName().toString()
+  /** List all tasty files occuring in the folder f or one of its subfolders */
+  def recursiveListFiles(f: File): Array[File] = {
+    val pattern = ".*test-classes/example.*\\.tasty".r
+    val files = f.listFiles
+    val folders = files.filter(_.isDirectory)
+    val tastyfiles = files.filter(_.toString match {
+      case pattern(x: _*) => true
+      case _              => false
+    })
+    tastyfiles ++ folders.flatMap(recursiveListFiles)
+  }
+
+  /** Returns a mapping from *.scala file to a list of tasty files. */
+  def getTastyFiles(artifactsPath: Path): HashMap[String, List[Path]] = {
+    val source_to_tasty: HashMap[String, List[Path]] = HashMap()
+    val tastyfiles = recursiveListFiles(artifactsPath.toFile())
+    recursiveListFiles(artifactsPath.toFile()).map(tasty_path => {
+      val (classpath, classname) = getClasspathClassname(tasty_path.toPath())
+      // We add an exception here to avoid crashing if we encountered
+      // a bad tasty file
+      try {
+        val inspecter = new TastyInspecter
+        ConsumeTasty(classpath, classname :: Nil, inspecter)
+        inspecter.source_path.foreach(
+          source =>
+            source_to_tasty +=
+              (source -> (tasty_path
+                .toPath() :: source_to_tasty.getOrElse(source, Nil))))
+      } catch {
+        case _: InvocationTargetException => println(tasty_path)
+      }
+    })
+    source_to_tasty
+  }
+
+  /** Infers a tuple (class path, class name) from a given path */
+  def getClasspathClassname(file: Path): (String, String) = {
+    val pat = """(.*)\..*""".r
+    val classpath = file.getParent().getParent().toString()
+    val modulename = file.getParent().getFileName().toString()
     val sourcename =
-    scalaFile.toFile().getName().toString() match {
-      case pat(name) => name
-      case _ => ""
+      file.toFile().getName().toString() match {
+        case pat(name) => name
+        case _         => ""
       }
-    val sdbconsumer = new SemanticdbConsumer
-    val _ = ConsumeTasty(classpath, (modulename + "." + sourcename) :: Nil, sdbconsumer)
-    sdbconsumer.toSemanticdb(scalac.text)
+    return (classpath, modulename + "." + sourcename)
+  }
 
+  def getTastySemanticdb(scalaFile: Path): s.TextDocument = {
+    val scalac = getScalacSemanticdb(scalaFile)
+
+    val tasty_files = source_to_tasty.getOrElse(
+      sourceDirectory.resolve(scalaFile).toString,
+      Nil)
+
+    val tasty_classes = tasty_files.map(getClasspathClassname)
+    // If we have more than one classpath then something went wrong
+    if (tasty_classes.groupBy((a, _) => a).size != 1) {
+      scalac
+    } else {
+      val (classpaths, classnames) = tasty_classes.unzip
+      val sdbconsumer = new SemanticdbConsumer
+
+      val _ = ConsumeTasty(classpaths.head, classnames, sdbconsumer)
+      sdbconsumer.toSemanticdb(scalac.text)
+    }
   }
 
   /** Fails the test if the s.TextDocument from tasty and semanticdb-scalac are not the same. */
@@ -61,9 +157,16 @@ class Tests {
     val diff =
       if (patch.getDeltas.isEmpty) ""
       else {
-        difflib.DiffUtils.generateUnifiedDiff(
-          "tasty", "scala2", obtainedLines, patch, 1
-        ).asScala.mkString("\n")
+        difflib.DiffUtils
+          .generateUnifiedDiff(
+            "tasty",
+            "scala2",
+            obtainedLines,
+            patch,
+            1
+          )
+          .asScala
+          .mkString("\n")
       }
     if (!diff.isEmpty) {
       fail("\n" + diff)