Eliminate designatorName

Author: odersky

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

@@ -1501,8 +1501,6 @@ object Types {
     private[this] var myName: ThisName = _
     private[this] var mySig: Signature = null
 
-    def designatorName: Name = designator.asInstanceOf[Name] // ### todo: remove
-
     private[dotc] def init()(implicit ctx: Context): this.type = {
       (designator: Designator) match { // dotty shortcoming: need the upcast
         case DerivedName(underlying, info: SignedName.SignedInfo) =>
@@ -1923,7 +1921,10 @@ object Types {
      *  the public name.
      */
     def shadowed(implicit ctx: Context): NamedType =
-      NamedType(prefix, designatorName.derived(ShadowedName))
+      designator match {
+        case designator: Symbol => this
+        case designator: Name => NamedType(prefix, designator.derived(ShadowedName))
+      }
 
     override def equals(that: Any) = that match {
       case that: NamedType =>

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

@@ -144,39 +144,41 @@ class TreePickler(pickler: TastyPickler) {
       pickleConstant(value)
     case tpe: NamedType =>
       val sym = tpe.symbol
-      def pickleDirectRef() = {
-        writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
-        pickleSymRef(sym)
-      }
       if (sym.is(Flags.Package)) {
         writeByte(if (tpe.isType) TYPEREFpkg else TERMREFpkg)
         pickleName(sym.fullName)
       }
-      else if (sym is Flags.BindDefinedType) {
-        registerDef(sym)
-        writeByte(BIND)
-        withLength {
-          pickleName(sym.name)
-          pickleType(sym.info)
-          pickleDirectRef()
-        }
-      }
       else if (tpe.prefix == NoPrefix) {
-        pickleDirectRef()
+        def pickleDirectRef() = {
+          writeByte(if (tpe.isType) TYPEREFdirect else TERMREFdirect)
+          pickleSymRef(sym)
+        }
+        if (sym is Flags.BindDefinedType) {
+          registerDef(sym)
+          writeByte(BIND)
+          withLength {
+            pickleName(sym.name)
+            pickleType(sym.info)
+            pickleDirectRef()
+          }
+        }
+        else pickleDirectRef()
       }
       else if (isLocallyDefined(sym)) {
         writeByte(if (tpe.isType) TYPEREFsymbol else TERMREFsymbol)
         pickleSymRef(sym); pickleType(tpe.prefix)
       }
-      else if (tpe.hasFixedSym) {
-        assert(tpe.symbol.isClass && tpe.symbol.is(Flags.Scala2x), tpe.symbol.showLocated)
-        writeByte(TYPEREF) // should be changed to a new entry that keeps track of prefix, symbol & owner
-        pickleName(tpe.name)
-        pickleType(tpe.prefix)
-      }
       else {
+        val name = tpe.designator match {
+          case designator: Symbol =>
+            assert(tpe.symbol.isClass && tpe.symbol.is(Flags.Scala2x), tpe.symbol.showLocated)
+            // Note: vulnerability here, since Scala2x allows several classes with same name and prefix
+            designator.name
+          case designator: Name =>
+            designator
+        }
         writeByte(if (tpe.isType) TYPEREF else TERMREF)
-        pickleName(tpe.designatorName); pickleType(tpe.prefix)
+        pickleName(name); pickleType(tpe.prefix)
       }
     case tpe: ThisType =>
       if (tpe.cls.is(Flags.Package) && !tpe.cls.isEffectiveRoot) {