Eliminate TastyNames

Author: odersky

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -20,6 +20,7 @@ object StdNames {
     val TRAIT_SETTER_SEPARATOR   = "$_setter_$"
     val SUPER_PREFIX             = "super$"
     val INITIALIZER_PREFIX       = "initial$"
+    val SHADOWED_PREFIX          = "(shadowed)"
   }
 
   abstract class DefinedNames[N <: Name] {

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

@@ -19,12 +19,12 @@ object DottyUnpickler {
 
   class TreeSectionUnpickler(posUnpickler: Option[PositionUnpickler])
   extends SectionUnpickler[TreeUnpickler]("ASTs") {
-    def unpickle(reader: TastyReader, tastyName: TastyName.Table) =
-      new TreeUnpickler(reader, tastyName, posUnpickler)
+    def unpickle(reader: TastyReader, nameAtRef: NameTable) =
+      new TreeUnpickler(reader, nameAtRef, posUnpickler)
   }
 
   class PositionsSectionUnpickler extends SectionUnpickler[PositionUnpickler]("Positions") {
-    def unpickle(reader: TastyReader, tastyName: TastyName.Table) =
+    def unpickle(reader: TastyReader, nameAtRef: NameTable) =
       new PositionUnpickler(reader)
   }
 }

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

@@ -4,63 +4,38 @@ package core
 package tasty
 
 import collection.mutable
-import Names.{Name, chrs, SimpleTermName}
+import Names.{Name, chrs, SimpleTermName, DerivedTermName}
 import NameOps.NameDecorator
 import NameExtractors._
 import Decorators._
 import TastyBuffer._
 import scala.io.Codec
-import TastyName._
 import TastyFormat._
 
 class NameBuffer extends TastyBuffer(10000) {
   import NameBuffer._
 
-  private val nameRefs = new mutable.LinkedHashMap[TastyName, NameRef]
+  private val nameRefs = new mutable.LinkedHashMap[Name, NameRef]
 
-  def nameIndex(name: TastyName): NameRef = nameRefs.get(name) match {
-    case Some(ref) =>
-      ref
-    case None =>
-      val ref = NameRef(nameRefs.size)
-      nameRefs(name) = ref
-      ref
-  }
-
-  def nameIndex(name: Name, toTasty: SimpleTermName => TastyName): NameRef = {
-    val tname = name.toTermName match {
-      case ModuleClassName(name1) =>
-        ModuleClass(nameIndex(name1, toTasty))
-      case SuperAccessorName(name1) =>
-        SuperAccessor(nameIndex(name1, toTasty))
-      case QualifiedName(prefix, selector) =>
-        Qualified(nameIndex(prefix, toTasty), nameIndex(selector))
-      case FlattenedName(prefix, selector) =>
-        Flattened(nameIndex(prefix, toTasty), nameIndex(selector))
-      case XpandedName(prefix, selector) =>
-        Expanded(nameIndex(prefix, toTasty), nameIndex(selector))
-      case DefaultGetterName(prefix, num) =>
-        DefaultGetter(nameIndex(prefix, toTasty), num)
-      case VariantName(prefix, sign) =>
-        Variant(nameIndex(prefix, toTasty), sign)
-      case name1 =>
-        if (name1.isShadowedName) Shadowed(nameIndex(name1.revertShadowed, toTasty))
-        else toTasty(name1.asSimpleName)
-    }
-    nameIndex(tname)
-  }
-
-  def nameIndex(name: Name): NameRef = nameIndex(name, Simple)
-
-  def nameIndex(str: String): NameRef = nameIndex(str.toTermName)
-
-  def fullNameIndex(name: Name): NameRef = {
-    def split(name: SimpleTermName): TastyName = {
-      val pos = name.lastIndexOf('.')
-      if (pos <= 0) Simple(name)
-      else Qualified(fullNameIndex(name.take(pos)), nameIndex(name.drop(pos + 1)))
-    }
-    nameIndex(name, split)
+  def nameIndex(name: Name): NameRef = {
+    val name1 = name.toTermName
+    nameRefs.get(name1) match {
+      case Some(ref) =>
+        ref
+      case None =>
+        name1 match {
+          case SignedName(original, Signature(params, result)) =>
+            nameIndex(original); nameIndex(result); params.foreach(nameIndex)
+          case AnyQualifiedName(prefix, info) =>
+            nameIndex(prefix); nameIndex(info.name)
+          case DerivedTermName(prefix, _) =>
+            nameIndex(prefix)
+          case _ =>
+        }
+        val ref = NameRef(nameRefs.size)
+        nameRefs(name1) = ref
+        ref
+      }
   }
 
   private def withLength(op: => Unit, lengthWidth: Int = 1): Unit = {
@@ -71,43 +46,44 @@ class NameBuffer extends TastyBuffer(10000) {
     putNat(lengthAddr, length, lengthWidth)
   }
 
-  def writeNameRef(ref: NameRef) = writeNat(ref.index)
+  def writeNameRef(ref: NameRef): Unit = writeNat(ref.index)
+  def writeNameRef(name: Name): Unit = writeNameRef(nameRefs(name.toTermName))
 
-  def pickleName(name: TastyName): Unit = name match {
-    case Simple(name) =>
+  def pickleNameContents(name: Name): Unit = name.toTermName match {
+    case name: SimpleTermName =>
       val bytes =
         if (name.length == 0) new Array[Byte](0)
         else Codec.toUTF8(chrs, name.start, name.length)
       writeByte(UTF8)
       writeNat(bytes.length)
       writeBytes(bytes, bytes.length)
-    case Qualified(qualified, selector) =>
+    case QualifiedName(qualified, selector) =>
       writeByte(QUALIFIED)
       withLength { writeNameRef(qualified); writeNameRef(selector) }
-    case Flattened(qualified, selector) =>
+    case FlattenedName(qualified, selector) =>
       writeByte(FLATTENED)
       withLength { writeNameRef(qualified); writeNameRef(selector) }
-    case Expanded(prefix, original) =>
+    case XpandedName(prefix, original) =>
       writeByte(EXPANDED)
       withLength { writeNameRef(prefix); writeNameRef(original) }
-    case Signed(original, params, result) =>
+    case SignedName(original, Signature(params, result)) =>
       writeByte(SIGNED)
       withLength(
           { writeNameRef(original); writeNameRef(result); params.foreach(writeNameRef) },
           if ((params.length + 2) * maxIndexWidth <= maxNumInByte) 1 else 2)
-    case ModuleClass(module) =>
+    case ModuleClassName(module) =>
       writeByte(OBJECTCLASS)
       withLength { writeNameRef(module) }
-    case SuperAccessor(accessed) =>
+    case SuperAccessorName(accessed) =>
       writeByte(SUPERACCESSOR)
       withLength { writeNameRef(accessed) }
-    case DefaultGetter(method, paramNumber) =>
+    case DefaultGetterName(method, paramNumber) =>
       writeByte(DEFAULTGETTER)
       withLength { writeNameRef(method); writeNat(paramNumber) }
-    case Shadowed(original) =>
+    case ShadowedName(original) =>
       writeByte(SHADOWED)
       withLength { writeNameRef(original) }
-    case Variant(original, sign) =>
+    case VariantName(original, sign) =>
       writeByte(VARIANT)
       withLength { writeNameRef(original); writeNat(sign + 1) }
   }
@@ -117,7 +93,7 @@ class NameBuffer extends TastyBuffer(10000) {
     for ((name, ref) <- nameRefs) {
       assert(ref.index == i)
       i += 1
-      pickleName(name)
+      pickleNameContents(name)
     }
   }
 }

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

@@ -26,6 +26,9 @@ object TastyBuffer {
    *  the value of 4 gives a maximal array size of 256M.
    */
   final val AddrWidth = 4
+
+  /** An address referring to a serialized name */
+  case class NameRef(index: Int) extends AnyVal
 }
 import TastyBuffer._
 

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

@@ -9,10 +9,11 @@ import TastyBuffer._
 import java.util.UUID
 import core.Symbols.Symbol
 import ast.tpd
+import Decorators._
 
 class TastyPickler {
 
-  private val sections = new mutable.ArrayBuffer[(TastyName.NameRef, TastyBuffer)]
+  private val sections = new mutable.ArrayBuffer[(NameRef, TastyBuffer)]
   val uuid = UUID.randomUUID()
 
   private val headerBuffer = {
@@ -28,7 +29,7 @@ class TastyPickler {
   val nameBuffer = new NameBuffer
 
   def newSection(name: String, buf: TastyBuffer) =
-    sections += ((nameBuffer.nameIndex(name), buf))
+    sections += ((nameBuffer.nameIndex(name.toTermName), buf))
 
   def assembleParts(): Array[Byte] = {
     def lengthWithLength(buf: TastyBuffer) = {

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

@@ -4,34 +4,24 @@ package tasty
 
 import Contexts._, Decorators._
 import printing.Texts._
-import TastyName._
+import Names.Name
 import StdNames._
 import TastyUnpickler._
-import TastyBuffer.Addr
+import TastyBuffer.{Addr, NameRef}
 import util.Positions.{Position, offsetToInt}
 import collection.mutable
 
 class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
 
   val unpickler = new TastyUnpickler(bytes)
-  import unpickler.{tastyName, unpickle}
+  import unpickler.{nameAtRef, unpickle}
 
-  def nameToString(name: TastyName): String = name match {
-    case Simple(name) => name.toString
-    case Qualified(qual, name) => nameRefToString(qual) + "." + nameRefToString(name)
-    case Signed(original, params, result) =>
-      i"${nameRefToString(original)}@${params.map(nameRefToString)}%,%:${nameRefToString(result)}"
-    case Expanded(prefix, original) => s"$prefix${nme.EXPAND_SEPARATOR}$original"
-    case ModuleClass(original) => nameRefToString(original) + "/MODULECLASS"
-    case SuperAccessor(accessed) => nameRefToString(accessed) + "/SUPERACCESSOR"
-    case DefaultGetter(meth, num) => nameRefToString(meth) + "/DEFAULTGETTER" + num
-    case Shadowed(original) => nameRefToString(original) + "/SHADOWED"
-  }
+  def nameToString(name: Name): String = name.debugString
 
-  def nameRefToString(ref: NameRef): String = nameToString(tastyName(ref))
+  def nameRefToString(ref: NameRef): String = nameToString(nameAtRef(ref))
 
   def printNames() =
-    for ((name, idx) <- tastyName.contents.zipWithIndex) {
+    for ((name, idx) <- nameAtRef.contents.zipWithIndex) {
       val index = "%4d: ".format(idx)
       println(index + nameToString(name))
     }
@@ -46,7 +36,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
 
   class TreeSectionUnpickler extends SectionUnpickler[Unit]("ASTs") {
     import TastyFormat._
-    def unpickle(reader: TastyReader, tastyName: TastyName.Table): Unit = {
+    def unpickle(reader: TastyReader, tastyName: NameTable): Unit = {
       import reader._
       var indent = 0
       def newLine() = {
@@ -116,7 +106,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
   }
 
   class PositionSectionUnpickler extends SectionUnpickler[Unit]("Positions") {
-    def unpickle(reader: TastyReader, tastyName: TastyName.Table): Unit = {
+    def unpickle(reader: TastyReader, tastyName: NameTable): Unit = {
       print(s"${reader.endAddr.index - reader.currentAddr.index}")
       val positions = new PositionUnpickler(reader).positions
       println(s" position bytes:")

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

@@ -4,7 +4,6 @@ package core
 package tasty
 
 import TastyBuffer._
-import TastyName.NameRef
 import collection.mutable
 
 /** A byte array buffer that can be filled with bytes or natural numbers in TASTY format,