Get name by reading the TASTy tree

Author: nicolasstucki

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

@@ -142,8 +142,14 @@ class Driver {
         val (classPaths, classNames) = fileNames0.map { name =>
           val path = Paths.get(name)
           if (!name.endsWith(".tasty")) ("", name)
-          else if (Files.exists(path)) TastyFileUtil.getClassName(path)
-          else {
+          else if (Files.exists(path)) {
+            TastyFileUtil.getClassName(path) match {
+              case Some(res) => res
+              case _ =>
+                ctx0.error(s"Could not load classname from $name.")
+                ("", name)
+            }
+          } else {
             ctx0.error(s"File $name does not exist.")
             ("", name)
           }

compiler/src/dotty/tools/dotc/core/tasty/TastyClassName.scala

@@ -0,0 +1,58 @@
+package dotty.tools.dotc
+package core
+package tasty
+
+import Contexts._, Decorators._
+import Names.{Name, TermName}
+import StdNames.nme
+import TastyUnpickler._
+import TastyBuffer.NameRef
+import util.Positions.offsetToInt
+import printing.Highlighting._
+
+/** Reads the package and class name of the class contained in this TASTy */
+class TastyClassName(bytes: Array[Byte]) {
+
+  val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
+  import unpickler.{nameAtRef, unpickle}
+
+  /** Returns a tuple with the package and class names */
+  def readName(): Option[(TermName, TermName)] = unpickle(new TreeSectionUnpickler)
+
+  class TreeSectionUnpickler extends SectionUnpickler[(TermName, TermName)](TreePickler.sectionName) {
+    import TastyFormat._
+    def unpickle(reader: TastyReader, tastyName: NameTable): (TermName, TermName) = {
+      import reader._
+      def readName() = {
+        val idx = readNat()
+        nameAtRef(NameRef(idx))
+      }
+      def readNames(pack: TermName): (TermName, TermName) = {
+        val tag = readByte()
+        if (tag >= firstLengthTreeTag) {
+          val len = readNat()
+          val end = currentAddr + len
+          tag match {
+            case TYPEDEF =>
+              val name = readName()
+              goto(end)
+              (pack, name)
+            case IMPORT | VALDEF =>
+              goto(end)
+              readNames(pack)
+            case PACKAGE =>
+              readNames(pack)
+          }
+        }
+        else tag match {
+          case TERMREFpkg | TYPEREFpkg =>
+            val packName = readName()
+            readNames(packName)
+          case _ =>
+            readNames(pack)
+        }
+      }
+      readNames(nme.EMPTY_PACKAGE)
+    }
+  }
+}

compiler/src/dotty/tools/dotc/fromtasty/TastyFileUtil.scala

@@ -1,6 +1,8 @@
-package dotty.tools.dotc.fromtasty
+package dotty.tools.dotc
+package fromtasty
 
 import java.nio.file.{Files, Path, Paths}
+import java.io
 
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.NameKinds
@@ -17,25 +19,20 @@ object TastyFileUtil {
    *    package foo
    *    class Foo
    *  ```
-   *  then `getClassName("./out/foo/Foo.tasty") returns `("./out", "foo.Foo")`
+   *  then `getClassName("./out/foo/Foo.tasty") returns `Some(("./out", "foo.Foo"))`
    */
-  def getClassName(path: Path): (String, String) = {
+  def getClassName(path: Path): Option[(String, String)] = {
     assert(path.toString.endsWith(".tasty"))
     assert(Files.exists(path))
     val bytes = Files.readAllBytes(path)
-    val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
-    val className =
-      unpickler.nameAtRef.contents.iterator.dropWhile {
-        name => name.toString == TreePickler.sectionName || name == nme.EMPTY_PACKAGE
-      }.takeWhile {
-        case name: SimpleName => name != nme.CONSTRUCTOR
-        case name => !name.is(NameKinds.ModuleClassName)
-      }.collect {
-        case name: SimpleName => name.toString
-      }.toList
-    val classInPath = className.mkString("", "/", ".tasty")
-    val classpath = path.toString.replace(classInPath, "")
-    (classpath, className.mkString("."))
+    val names = new core.tasty.TastyClassName(bytes).readName()
+    names.map { case (packName, className) =>
+      val fullName = s"$packName.${className.lastPart}"
+      val classInPath = fullName.replace(".", io.File.separator) + ".tasty"
+      val classpath = path.toString.replace(classInPath, "")
+      (classpath, fullName)
+    }
+
   }
 
 }