Decode names of package members on enter

Avoids mutable names and the hassles associated with them.

Author: odersky

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

@@ -107,7 +107,7 @@ object SymDenotations {
   class SymDenotation private[SymDenotations] (
     symbol: Symbol,
     ownerIfExists: Symbol,
-    initName: Name,
+    val name: Name,
     initFlags: FlagSet,
     initInfo: Type,
     initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol) {
@@ -125,18 +125,11 @@ object SymDenotations {
 
     // ------ Getting and setting fields -----------------------------
 
-    private[this] var myName = initName
     private[this] var myFlags: FlagSet = adaptFlags(initFlags)
     private[this] var myInfo: Type = initInfo
     private[this] var myPrivateWithin: Symbol = initPrivateWithin
     private[this] var myAnnotations: List[Annotation] = Nil
 
-    /** The name of the symbol */
-    def name = myName
-
-    /** Update the name; only called when unpickling top-level classes */
-    private[core] def name_=(n: Name) = myName = n
-
     /** The owner of the symbol; overridden in NoDenotation */
     def owner: Symbol = ownerIfExists
 
@@ -1212,12 +1205,12 @@ object SymDenotations {
   class ClassDenotation private[SymDenotations] (
     symbol: Symbol,
     ownerIfExists: Symbol,
-    initName: Name,
+    name: Name,
     initFlags: FlagSet,
     initInfo: Type,
     initPrivateWithin: Symbol,
     initRunId: RunId)
-    extends SymDenotation(symbol, ownerIfExists, initName, initFlags, initInfo, initPrivateWithin) {
+    extends SymDenotation(symbol, ownerIfExists, name, initFlags, initInfo, initPrivateWithin) {
 
     import util.LRUCache
 
@@ -1260,11 +1253,6 @@ object SymDenotations {
       myTypeParams
     }
 
-    override private[core] def name_=(n: Name) = {
-      fullNameCache = SimpleMap.Empty
-      super.name_=(n)
-    }
-
     override protected[dotc] final def info_=(tp: Type) = {
       super.info_=(tp)
       myTypeParams = null // changing the info might change decls, and with it typeParams

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

@@ -40,7 +40,7 @@ class SymbolLoaders {
   def enterClass(
       owner: Symbol, name: PreName, completer: SymbolLoader,
       flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
-    val cls = ctx.newClassSymbol(owner, name.toTypeName, flags, completer, assocFile = completer.sourceFileOrNull)
+    val cls = ctx.newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, assocFile = completer.sourceFileOrNull)
     enterNew(owner, cls, completer, scope)
   }
 
@@ -50,7 +50,7 @@ class SymbolLoaders {
       owner: Symbol, name: PreName, completer: SymbolLoader,
       modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
     val module = ctx.newModuleSymbol(
-      owner, name.toTermName, modFlags, clsFlags,
+      owner, name.toTermName.decode, modFlags, clsFlags,
       (module, _) => completer.proxy withDecls newScope withSourceModule (_ => module),
       assocFile = completer.sourceFileOrNull)
     enterNew(owner, module, completer, scope)
@@ -166,13 +166,7 @@ class SymbolLoaders {
       override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = {
         val mangled = name.mangled
         val e = super.lookupEntry(mangled)
-        if (e != null) {
-          // Eagerly update symbol's name to undecoded name to avpid the name
-          // spearding to types.
-          if (name.toSimpleName != mangled && e.sym.initialDenot.name == mangled)
-            e.sym.initialDenot.name = name
-          e
-        }
+        if (e != null) e
         else if (_sourceModule.initialDenot.name == nme.scala_ && _sourceModule == defn.ScalaPackageVal &&
                  name.isTypeName && name.isSyntheticFunction)
           newScopeEntry(defn.newFunctionNTrait(name.asTypeName))

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

@@ -436,7 +436,6 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
         roots.find(root => (root.owner eq ctx.owner) && root.name.mangled == mname) match {
           case Some(rootd) =>
             pickling.println(i"overwriting ${rootd.symbol} # ${rootd.hashCode}")
-            rootd.name = name
             rootd.info = adjustIfModule(
                 new Completer(ctx.owner, subReader(start, end)) with SymbolLoaders.SecondCompleter)
             rootd.flags = flags &~ Touched // allow one more completion

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -460,7 +460,6 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     //if (isModuleClassRoot) println(s"moduleClassRoot of $moduleClassRoot found at $readIndex, flags = $flags") // !!! DEBUG
 
     def completeRoot(denot: ClassDenotation, completer: LazyType): Symbol = {
-      denot.name = name
       denot.setFlag(flags)
       denot.resetFlag(Touched) // allow one more completion
       denot.info = completer