Compare unmangled name when searching for roots

Compare unmangled name when searching for roots in Scala2 and Tasty
unpickling. Since we now load files with their unmangled name, we
don't need to go through mangled names anymore.

Author: odersky

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

@@ -107,7 +107,7 @@ object SymDenotations {
   class SymDenotation private[SymDenotations] (
     symbol: Symbol,
     ownerIfExists: Symbol,
-    val name: Name,
+    final val name: Name,
     initFlags: FlagSet,
     initInfo: Type,
     initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol) {
@@ -373,18 +373,11 @@ object SymDenotations {
         // might have been moved from different origins into the same class
 
     /** The name with which the denoting symbol was created */
-    final def originalName(implicit ctx: Context) =
-      initial.effectiveName
+    final def originalName(implicit ctx: Context) = initial.effectiveName
 
     /** The encoded full path name of this denotation, where outer names and inner names
-     *  are separated by `separator` strings.
-     *  Never translates expansions of operators back to operator symbol.
-     *  Drops package objects. Represents each term in the owner chain by a simple `~`.
-     *  (Note: scalac uses nothing to represent terms, which can cause name clashes
-     *   between same-named definitions in different enclosing methods. Before this commit
-     *   we used `$' but this can cause ambiguities with the class separator '$').
-     *  A separator "" means "flat name"; the real separator in this case is "$" and
-     *  enclosing packages do not form part of the name.
+     *  are separated by `separator` strings as indicated by the given name kind.
+     *  Drops package objects. Represents each term in the owner chain by a simple `_$`.
      */
     def fullNameSeparated(kind: QualifiedNameKind)(implicit ctx: Context): Name =
       if (symbol == NoSymbol ||

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

@@ -417,7 +417,6 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       val end = readEnd()
       var name: Name = readName()
       if (tag == TYPEDEF || tag == TYPEPARAM) name = name.toTypeName
-      val mname = name.mangled
       skipParams()
       val ttag = nextUnsharedTag
       val isAbsType = isAbstractType(ttag)
@@ -433,7 +432,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
       def adjustIfModule(completer: LazyType) =
         if (flags is Module) ctx.adjustModuleCompleter(completer, name) else completer
       val sym =
-        roots.find(root => (root.owner eq ctx.owner) && root.name.mangled == mname) match {
+        roots.find(root => (root.owner eq ctx.owner) && root.name == name) match {
           case Some(rootd) =>
             pickling.println(i"overwriting ${rootd.symbol} # ${rootd.hashCode}")
             rootd.info = adjustIfModule(

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

@@ -449,8 +449,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     }
     name = name.mapLast(_.decode)
 
-    val mname = name.mangled
-    def nameMatches(rootName: Name) = mname == rootName.mangled
+    def nameMatches(rootName: Name) = name == rootName
     def isClassRoot = nameMatches(classRoot.name) && (owner == classRoot.owner) && !(flags is ModuleClass)
     def isModuleClassRoot = nameMatches(moduleClassRoot.name) && (owner == moduleClassRoot.owner) && (flags is Module)
     def isModuleRoot = nameMatches(moduleClassRoot.name.sourceModuleName) && (owner == moduleClassRoot.owner) && (flags is Module)