Eliminate TastyNames

11 files changed, 107 insertions, 219 deletions

diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 70730b841..bf404d630 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/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] {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala
index 2c93819d5..28916a781 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala
+++ b/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)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
index e82a9b618..0101ff25d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
+++ b/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)
     }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala
index 13bc95028..40782f534 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala
+++ b/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._
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyName.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyName.scala
deleted file mode 100644
index 769ecfbfc..000000000
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyName.scala
+++ /dev/null
@@ -1,32 +0,0 @@
-package dotty.tools
-package dotc
-package core
-package tasty
-
-import core.Names.SimpleTermName
-import collection.mutable
-
-abstract class TastyName
-
-object TastyName {
-
-  case class NameRef(index: Int) extends AnyVal
-
-  case class Simple(name: SimpleTermName) extends TastyName
-  case class Qualified(qualified: NameRef, selector: NameRef) extends TastyName
-  case class Expanded(prefix: NameRef, original: NameRef) extends TastyName
-  case class Flattened(prefix: NameRef, original: NameRef) extends TastyName
-  case class Signed(original: NameRef, params: List[NameRef], result: NameRef) extends TastyName
-  case class ModuleClass(module: NameRef) extends TastyName
-  case class SuperAccessor(accessed: NameRef) extends TastyName
-  case class DefaultGetter(method: NameRef, num: Int) extends TastyName
-  case class Shadowed(original: NameRef) extends TastyName
-  case class Variant(original: NameRef, sign: Int) extends TastyName
-
-  class Table extends (NameRef => TastyName) {
-    private val names = new mutable.ArrayBuffer[TastyName]
-    def add(name: TastyName) = names += name
-    def apply(ref: NameRef) = names(ref.index)
-    def contents: Iterable[TastyName] = names
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala
index c844d522e..cc2e4dd58 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.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) = {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
index ce3722ff1..a5c870881 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.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:")
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala
index e583c4793..af5e78891 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.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,
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
index e6b43e6b4..6dd22db88 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
@@ -4,14 +4,23 @@ package tasty
 
 import scala.collection.mutable
 import TastyFormat._
-import Names.{Name, termName}
+import TastyBuffer.NameRef
+import Names.{Name, TermName, termName}
+import NameExtractors._
 import java.util.UUID
 
 object TastyUnpickler {
   class UnpickleException(msg: String) extends Exception(msg)
 
   abstract class SectionUnpickler[R](val name: String) {
-    def unpickle(reader: TastyReader, tastyName: TastyName.Table): R
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): R
+  }
+
+  class NameTable extends (NameRef => TermName) {
+    private val names = new mutable.ArrayBuffer[TermName]
+    def add(name: TermName) = names += name
+    def apply(ref: NameRef) = names(ref.index)
+    def contents: Iterable[TermName] = names
   }
 }
 
@@ -23,18 +32,15 @@ class TastyUnpickler(reader: TastyReader) {
   def this(bytes: Array[Byte]) = this(new TastyReader(bytes))
 
   private val sectionReader = new mutable.HashMap[String, TastyReader]
-  val tastyName = new TastyName.Table
+  val nameAtRef = new NameTable
 
-  def check(cond: Boolean, msg: => String) =
+  private def check(cond: Boolean, msg: => String) =
     if (!cond) throw new UnpickleException(msg)
 
-  def readString(): String = {
-    val TastyName.Simple(name) = tastyName(readNameRef())
-    name.toString
-  }
+  private def readName(): TermName = nameAtRef(readNameRef())
+  private def readString(): String = readName().toString
 
-  def readName(): TastyName = {
-    import TastyName._
+  private def readNameContents(): TermName = {
     val tag = readByte()
     val length = readNat()
     val start = currentAddr
@@ -42,28 +48,30 @@ class TastyUnpickler(reader: TastyReader) {
     val result = tag match {
       case UTF8 =>
         goto(end)
-        Simple(termName(bytes, start.index, length))
+        termName(bytes, start.index, length)
       case QUALIFIED =>
-        Qualified(readNameRef(), readNameRef())
+        QualifiedName(readName(), readName().asSimpleName)
       case FLATTENED =>
-        Flattened(readNameRef(), readNameRef())
+        FlattenedName(readName(), readName().asSimpleName)
       case EXPANDED =>
-        Expanded(readNameRef(), readNameRef())
+        XpandedName(readName(), readName().asSimpleName)
       case SIGNED =>
-        val original = readNameRef()
-        val result = readNameRef()
-        val params = until(end)(readNameRef())
-        Signed(original, params, result)
+        val original = readName()
+        val result = readName().toTypeName
+        val params = until(end)(readName().toTypeName)
+        var sig = Signature(params, result)
+        if (sig == Signature.NotAMethod) sig = Signature.NotAMethod
+        SignedName(original, sig)
       case OBJECTCLASS =>
-        ModuleClass(readNameRef())
+        ModuleClassName(readName())
       case SUPERACCESSOR =>
-        SuperAccessor(readNameRef())
+        SuperAccessorName(readName())
       case DEFAULTGETTER =>
-        DefaultGetter(readNameRef(), readNat())
+        DefaultGetterName(readName(), readNat())
       case SHADOWED =>
-        Shadowed(readNameRef())
+        ShadowedName(readName())
       case VARIANT =>
-        Variant(readNameRef(), readNat() - 1)
+        VariantName(readName(), readNat() - 1)
     }
     assert(currentAddr == end, s"bad name $result $start $currentAddr $end")
     result
@@ -81,10 +89,10 @@ class TastyUnpickler(reader: TastyReader) {
     new UUID(readUncompressedLong(), readUncompressedLong())
   }
 
-  val uuid = readHeader()
+  private val uuid = readHeader()
 
   locally {
-    until(readEnd()) { tastyName.add(readName()) }
+    until(readEnd()) { nameAtRef.add(readNameContents()) }
     while (!isAtEnd) {
       val secName = readString()
       val secEnd = readEnd()
@@ -95,5 +103,5 @@ class TastyUnpickler(reader: TastyReader) {
 
   def unpickle[R](sec: SectionUnpickler[R]): Option[R] =
     for (reader <- sectionReader.get(sec.name)) yield
-      sec.unpickle(reader, tastyName)
+      sec.unpickle(reader, nameAtRef)
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index d25adfd29..d1f2a3766 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -19,7 +19,7 @@ class TreePickler(pickler: TastyPickler) {
   val buf = new TreeBuffer
   pickler.newSection("ASTs", buf)
   import buf._
-  import pickler.nameBuffer.{nameIndex, fullNameIndex}
+  import pickler.nameBuffer.nameIndex
   import ast.tpd._
 
   private val symRefs = new mutable.HashMap[Symbol, Addr]
@@ -53,11 +53,8 @@ class TreePickler(pickler: TastyPickler) {
   }
 
   private def pickleName(name: Name): Unit = writeNat(nameIndex(name).index)
-  private def pickleName(name: TastyName): Unit = writeNat(nameIndex(name).index)
-  private def pickleNameAndSig(name: Name, sig: Signature) = {
-    val Signature(params, result) = sig
-    pickleName(TastyName.Signed(nameIndex(name), params.map(fullNameIndex), fullNameIndex(result)))
-  }
+  private def pickleNameAndSig(name: Name, sig: Signature) =
+    pickleName(SignedName(name.toTermName, sig))
 
   private def pickleName(sym: Symbol)(implicit ctx: Context): Unit = {
     val nameRef =
@@ -65,19 +62,7 @@ class TreePickler(pickler: TastyPickler) {
         if (sym is Flags.ExpandedName) assert(sym.name.is(XpandedName))
         nameIndex(sym.name)
       }
-      else {
-        def encodeSuper(name: Name): TastyName.NameRef =
-          if (sym is Flags.SuperAccessor) {
-            val NameOps.SuperAccessorName(n) = name
-            nameIndex(TastyName.SuperAccessor(nameIndex(n)))
-          } else nameIndex(name)
-        if (sym is Flags.ExpandedName)
-          nameIndex(
-            TastyName.Expanded(
-              nameIndex(sym.name.expandedPrefix),
-              encodeSuper(sym.name.unexpandedName)))
-        else encodeSuper(sym.name)
-      }
+      else ???
     writeNat(nameRef.index)
   }
 
@@ -132,7 +117,7 @@ class TreePickler(pickler: TastyPickler) {
       writeLongInt(java.lang.Double.doubleToRawLongBits(c.doubleValue))
     case StringTag =>
       writeByte(STRINGconst)
-      writeNat(nameIndex(c.stringValue).index)
+      pickleName(c.stringValue.toTermName)
     case NullTag =>
       writeByte(NULLconst)
     case ClazzTag =>
@@ -184,7 +169,7 @@ class TreePickler(pickler: TastyPickler) {
         }
       if (sym.is(Flags.Package)) {
         writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
-        pickleName(qualifiedName(sym))
+        pickleName(sym.fullName)
       }
       else if (sym is Flags.BindDefinedType) {
         registerDef(sym)
@@ -284,7 +269,7 @@ class TreePickler(pickler: TastyPickler) {
 
   def picklePackageRef(pkg: Symbol)(implicit ctx: Context): Unit = {
     writeByte(TERMREFpkg)
-    pickleName(qualifiedName(pkg))
+    pickleName(pkg.fullName)
   }
 
   def pickleMethodic(tag: Int, tpe: LambdaType)(implicit ctx: Context) = {
@@ -581,10 +566,6 @@ class TreePickler(pickler: TastyPickler) {
     pickleName(id.name)
   }
 
-  def qualifiedName(sym: Symbol)(implicit ctx: Context): TastyName =
-    if (sym.isRoot || sym.owner.isRoot) TastyName.Simple(sym.name.toTermName.asSimpleName)
-    else TastyName.Qualified(nameIndex(qualifiedName(sym.owner)), nameIndex(sym.name))
-
   def pickleModifiers(sym: Symbol)(implicit ctx: Context): Unit = {
     import Flags._
     val flags = sym.flags
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index f74cdc36a..11c04e2b4 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -23,9 +23,8 @@ import config.Config
  *  @param tastyName       the nametable
  *  @param posUNpicklerOpt the unpickler for positions, if it exists
  */
-class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpicklerOpt: Option[PositionUnpickler]) {
+class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpicklerOpt: Option[PositionUnpickler]) {
   import TastyFormat._
-  import TastyName._
   import TreeUnpickler._
   import tpd._
 
@@ -76,31 +75,6 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
     new TreeReader(reader).readTopLevel()(ctx.addMode(Mode.AllowDependentFunctions))
   }
 
-  def toTermName(tname: TastyName): TermName = tname match {
-    case Simple(name) => name
-    case Qualified(qual, name) =>
-      if (Config.semanticNames) qualTermName(qual, name, ".")
-      else toTermName(qual) ++ "." ++ toTermName(name)
-    case Flattened(qual, name) =>
-      if (Config.semanticNames) qualTermName(qual, name, "$")
-      else toTermName(qual) ++ "$" ++ toTermName(name)
-    case Expanded(prefix, original) =>
-      if (Config.semanticNames) qualTermName(prefix, original, str.EXPAND_SEPARATOR)
-      else toTermName(original).expandedName(toTermName(prefix))
-    case Signed(original, params, result) => toTermName(original)
-    case Shadowed(original) => toTermName(original).shadowedName
-    case ModuleClass(original) => toTermName(original).moduleClassName.toTermName
-    case SuperAccessor(accessed) => toTermName(accessed).superName
-    case DefaultGetter(meth, num) => toTermName(meth).defaultGetterName(num)
-    case Variant(original, sign) => VariantName(toTermName(original), sign)
-  }
-
-  private def qualTermName(qual: NameRef, name: NameRef, sep: String) =
-    separatorToQualified(sep)(toTermName(qual), toTermName(name).asSimpleName)
-
-  def toTermName(ref: NameRef): TermName = toTermName(tastyName(ref))
-  def toTypeName(ref: NameRef): TypeName = toTermName(ref).toTypeName
-
   class Completer(owner: Symbol, reader: TastyReader) extends LazyType {
     import reader._
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
@@ -178,17 +152,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
       else tag
     }
 
-    def readName(): TermName = toTermName(readNameRef())
-
-    def readNameSplitSig()(implicit ctx: Context): Any /* TermName | (TermName, Signature) */ =
-      tastyName(readNameRef()) match {
-        case Signed(original, params, result) =>
-          var sig = Signature(params map toTypeName, toTypeName(result))
-          if (sig == Signature.NotAMethod) sig = Signature.NotAMethod
-          (toTermName(original), sig)
-        case name =>
-          toTermName(name)
-      }
+    def readName(): TermName = nameAtRef(readNameRef())
 
 // ------ Reading types -----------------------------------------------------
 
@@ -318,9 +282,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
           val name =  readName().toTypeName
           TypeRef(readType(), name)
         case TERMREF =>
-          readNameSplitSig() match {
-            case name: TermName => TermRef.all(readType(), name)
-            case (name: TermName, sig: Signature) => TermRef.withSig(readType(), name, sig)
+          readName() match {
+            case SignedName(name, sig) => TermRef.withSig(readType(), name, sig)
+            case name => TermRef.all(readType(), name)
           }
         case THIS =>
           ThisType.raw(readType().asInstanceOf[TypeRef])
@@ -451,8 +415,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
       val start = currentAddr
       val tag = readByte()
       val end = readEnd()
-      val rawName = tastyName(readNameRef())
-      var name: Name = toTermName(rawName)
+      var name: Name = readName()
       if (tag == TYPEDEF || tag == TYPEPARAM) name = name.toTypeName
       skipParams()
       val ttag = nextUnsharedTag
@@ -464,13 +427,11 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
       val rhsIsEmpty = noRhs(end)
       if (!rhsIsEmpty) skipTree()
       val (givenFlags, annots, privateWithin) = readModifiers(end)
-      def nameFlags(tname: TastyName): FlagSet = tname match {
-        case TastyName.Expanded(_, original) => ExpandedName | nameFlags(tastyName(original))
-        case TastyName.SuperAccessor(original) => Flags.SuperAccessor | nameFlags(tastyName(original))
-        case _ => EmptyFlags
-      }
+      val nameFlags =
+        (if (name.is(XpandedName)) ExpandedName else EmptyFlags) |
+        (if (name.is(NameExtractors.SuperAccessorName)) SuperAccessor else EmptyFlags)
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
-      val flags = normalizeFlags(tag, givenFlags | nameFlags(rawName), name, isAbsType, rhsIsEmpty)
+      val flags = normalizeFlags(tag, givenFlags | nameFlags, name, isAbsType, rhsIsEmpty)
       def adjustIfModule(completer: LazyType) =
         if (flags is Module) ctx.adjustModuleCompleter(completer, name) else completer
       val sym =
@@ -918,9 +879,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
         case SELECT =>
           def readRest(name: Name, sig: Signature) =
             completeSelect(name, TermRef.withSig(_, name.asTermName, sig))
-          readNameSplitSig match {
-            case name: Name => readRest(name, Signature.NotAMethod)
-            case (name: Name, sig: Signature) => readRest(name, sig)
+          readName() match {
+            case SignedName(name, sig) => readRest(name, sig)
+            case name => readRest(name, Signature.NotAMethod)
           }
         case SELECTtpt =>
           val name = readName().toTypeName