Improve test infrastructure and fix build errors:

- automatic scala version inference in test suite
- remove error message in test suite
- implemented derived statements in classdef
- fix bugs shown by rebase

Author: poechsel

semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala

@@ -61,13 +61,19 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
       }
     }
 
+    def arePositionEqual(p1 : Position, p2 : Position) : Boolean = {
+      p1.start == p2.start &&
+      p1.end == p2.end &&
+      p1.sourceFile == p2.sourceFile
+    }
+
     object Traverser extends TreeTraverser {
       implicit class TreeExtender(tree: Tree) {
         def isUserCreated: Boolean = {
           val children: List[Position] =
             ChildTraverser.getChildren(tree)(reflect.rootContext).map(_.pos)
-          return !((tree.pos.exists && tree.pos.start == tree.pos.end && children == Nil) || children
-            .exists(_ == tree.pos))
+          return !((tree.pos.exists && tree.pos.start == tree.pos.end && children == Nil) ||
+            children.exists(arePositionEqual(tree.pos, _)))
         }
       }
 
@@ -76,8 +82,8 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
           val children: List[Position] =
             ChildTraverser.getChildrenType(tree)(reflect.rootContext).collect(_ match {
             case IsTypeTree(tt) => tt.pos})
-          return !((tree.pos.exists && tree.pos.start == tree.pos.end && children == Nil) || children
-            .exists(_ == tree.pos))
+          return !((tree.pos.exists && tree.pos.start == tree.pos.end && children == Nil) ||
+            children.exists(arePositionEqual(tree.pos, _)))
         }
       }
 
@@ -457,7 +463,6 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
         // dotty will generate a ValDef for the x, but the x will also
         // be present in the constructor, thus making a double definition
         if (symbolPathsMap.contains(key)) return
-
         symbolPathsMap += key
         occurrences =
           occurrences :+
@@ -508,7 +513,7 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
       def addOccurencePatternTree(tree: Pattern,
                                   type_symbol: s.SymbolOccurrence.Role,
                                   range: s.Range): Unit = {
-        if (tree.isUserCreated) {
+        if (tree.symbol.isUseful && tree.isUserCreated) {
           addOccurence(tree.symbol, type_symbol, range)
         }
       }
@@ -780,7 +785,7 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
           case Term.Apply(_, _) => {
             super.traverseTree(tree)
           }
-          case cl @ ClassDef(classname, constr, parents, selfopt, statements) => {
+          case ClassDef(classname, constr, parents, derived, selfopt, statements) => {
             // we first add the class to the symbol list
             addOccurenceTree(tree,
                              s.SymbolOccurrence.Role.DEFINITION,
@@ -798,27 +803,12 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
               val rightmost = typesParameters.reverse.head.pos.end
               val end_ = nextCharacterSkipComments(sourceCode, rightmost) + 1
               fittedInitClassRange = Some(
-                s.Range(tree.symbol.pos.startLine,
+                s.Range(0,
                         end_,
-                        tree.symbol.pos.startLine,
+                        0,
                         end_))
             }
 
-/*s
-            if (!constr.isUserCreated) {
-              fittedInitClassRange = Some(
-                s.Range(tree.symbol.pos.startLine,
-                        tree.symbol.pos.startColumn + classname.length + 1,
-                        tree.symbol.pos.startLine,
-                        tree.symbol.pos.startColumn + classname.length + 1))
-            } else {
-              fittedInitClassRange = Some(
-                s.Range(constr.symbol.pos.startLine,
-                        constr.symbol.pos.startColumn,
-                        constr.symbol.pos.endLine,
-                        constr.symbol.pos.endColumn))
-            }*/
-
             disableConstrParamTraversal = true
               traverseTree(constr)
             disableConstrParamTraversal = false
@@ -865,6 +855,8 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
               case _ =>
             }
 
+            derived.foreach(traverseTypeTree)
+
             classStacks = tree.symbol :: classStacks
 
             val paramsPosMapping = generateParamsPosMapping(constr)
@@ -1058,7 +1050,6 @@ class SemanticdbConsumer(sourceFile: java.nio.file.Path) extends TastyConsumer {
       }
 
     }
-
     Traverser.traverseTree(root)(reflect.rootContext)
   }
 

semanticdb/src/dotty/semanticdb/Utils.scala

@@ -31,10 +31,10 @@ object Utils {
 
   /** List all tasty files occuring in the folder f or one of its subfolders */
   def recursiveListFiles(f: File, prefix : String = ""): Array[File] = {
-    val pattern = (prefix + ".*\\.tasty").r
+    val pattern = (".*" + prefix + ".*\\.tasty").r
     val files = f.listFiles
     val folders = files.filter(_.isDirectory)
-    val tastyfiles = files.filter(_.toString match {
+    val tastyfiles = files.filter(_.toPath.toString match {
       case pattern(x: _*) => true
       case _              => false
     })
@@ -45,7 +45,7 @@ object Utils {
   def getTastyFiles(classPath: Path, prefix : String = ""): HashMap[String, List[Path]] = {
     val sourceToTasty: HashMap[String, List[Path]] = HashMap()
     val tastyfiles = recursiveListFiles(classPath.toFile(), prefix)
-    recursiveListFiles(classPath.toFile()).map(tastyPath => {
+    tastyfiles.map(tastyPath => {
       val (classpath, classname) = getClasspathClassname(tastyPath.toPath())
       // We add an exception here to avoid crashing if we encountered
       // a bad tasty file
@@ -58,7 +58,7 @@ object Utils {
               (source -> (tastyPath
                 .toPath().toAbsolutePath :: sourceToTasty.getOrElse(source, Nil))))
       } catch {
-        case _: InvocationTargetException => println(tastyPath)
+        case _: InvocationTargetException => ()
       }
     })
     sourceToTasty
@@ -69,8 +69,13 @@ object Utils {
   extracted from the compilation artifacts found in [classPath].
   */
   def getClassNames(classPath: Path, scalaFile: Path, prefix : String = ""): List[String] = {
+    val tastyFiles = getTastyFiles(classPath.toAbsolutePath, prefix)
+    getClassNamesCached(scalaFile, tastyFiles)
+  }
+
+  def getClassNamesCached(scalaFile: Path, allFiles : HashMap[String, List[Path]]): List[String] = {
     val tastyFiles =
-      getTastyFiles(classPath.toAbsolutePath, prefix)
+      allFiles
       .getOrElse(scalaFile.toString, Nil)
 
     val tastyClasses = tastyFiles.map(getClasspathClassname)

semanticdb/test/dotty/semanticdb/Semanticdbs.scala

@@ -81,8 +81,10 @@ object Semanticdbs {
    **/
   def printTextDocument(doc: s.TextDocument): String = {
     val sb = new StringBuilder
-    val occurrences = doc.occurrences.sorted
     val sourceFile = SourceFile.virtual(doc.uri, doc.text)
+    implicit val occurrenceOrdering: Ordering[s.SymbolOccurrence] =
+      buildOccurrenceOrdering(sourceFile)
+    val occurrences = doc.occurrences.sorted
     var offset = 0
     occurrences.foreach { occ =>
       val range = occ.range.get
@@ -98,35 +100,28 @@ object Semanticdbs {
   }
 
   /** Sort symbol occurrences by their start position. */
-  implicit val occurrenceOrdering: Ordering[s.SymbolOccurrence] =
+  def buildOccurrenceOrdering(sourceFile: SourceFile): Ordering[s.SymbolOccurrence] = {
     new Ordering[s.SymbolOccurrence] {
+      def rangeToTuple(r : s.Range): (Int, Int) = {
+        val start = sourceFile.lineToOffset(r.startLine) + r.startCharacter
+        val end = sourceFile.lineToOffset(r.endLine) + r.endCharacter
+        (start, end)
+      }
+
       override def compare(x: s.SymbolOccurrence, y: s.SymbolOccurrence): Int = {
         if (x.range.isEmpty) 0
         else if (y.range.isEmpty) 0
         else {
-          val a = x.range.get
-          val b = y.range.get
-          val byLine = Integer.compare(
-            a.startLine,
-            b.startLine
-          )
-          if (byLine != 0) {
-            byLine
+          val (as, ae) = rangeToTuple(x.range.get)
+          val (bs, be) = rangeToTuple(y.range.get)
+          val byStart = Integer.compare(as, bs)
+          if (byStart != 0) {
+            byStart
           } else {
-            val byCharacter = Integer.compare(
-              a.startCharacter,
-              b.startCharacter
-            )
-            if (byCharacter == 0) {
-              Integer.compare(
-                a.endCharacter,
-                b.endCharacter
-              )
-            } else {
-              byCharacter
-            }
+            Integer.compare(ae, be)
           }
         }
       }
     }
+  }
 }

semanticdb/test/dotty/semanticdb/Tests.scala

@@ -82,9 +82,15 @@ class Tests {
       }
   }
 
-  // TODO: update scala-0.13 on version change (or resolve automatically)
-  final def tastyClassDirectory =
-    Paths.get("out/bootstrap/dotty-semanticdb/scala-0.12/test-classes/")
+  final def tastyClassDirectory = {
+    val root = "out/bootstrap/dotty-semanticdb/"
+    val files = Paths.get(root).toFile().listFiles
+    val scalaFolderReg = """scala-(\d+)\.(\d+)""".r
+    val (_, _, path) = files.collect(file => file.getName match {
+      case scalaFolderReg(major, minor) => (major, minor, file.getName)
+     }).max
+    Paths.get(root, path, "test-classes")
+  }
 
   val sourceroot = Paths.get("semanticdb/input").toAbsolutePath
   val sourceDirectory = sourceroot.resolve("src/main/scala")
@@ -97,9 +103,11 @@ class Tests {
     semanticdbLoader.resolve(scalaFile).get
   }
 
+  final def allTastyFiles = Utils.getTastyFiles(tastyClassDirectory, "example")
+
   /** Returns the SemanticDB for this Scala source file. */
   def getTastySemanticdb(classPath: Path, scalaFile: Path) : s.TextDocument = {
-    val classNames = Utils.getClassNames(classPath, scalaFile, "example/")
+    val classNames = Utils.getClassNamesCached(scalaFile, allTastyFiles)
     val sdbconsumer = new SemanticdbConsumer(scalaFile)
 
     val _ = ConsumeTasty(classPath.toString, classNames, sdbconsumer)
@@ -144,7 +152,6 @@ class Tests {
     }
   }
 
-
   @Test def testAccess(): Unit = checkFile("example/Access.scala")
   @Test def testAdvanced(): Unit = checkFile("example/Advanced.scala")
   @Test def testAnonymous(): Unit = checkFile("example/Anonymous.scala")
@@ -181,5 +188,4 @@ class Tests {
   @Test def testSynthetic(): Unit = checkFile("example/Synthetic.scala")
   @Test def testBinaryOp(): Unit = checkFile("example/BinaryOp.scala")
   @Test def testDottyPredef(): Unit = checkFile("example/DottyPredef.scala")
-
 }