Fix #560 - refactor flatName

Merge with fullNameSeparated. Take into account that static nested
classes are separated only with a single '$' from the enclosing object.
Previous scheme took the module class as owner, which led to a double '$$'.

Author: odersky

src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -554,7 +554,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def fullName: String = sym.showFullName
     def simpleName: Name = sym.name
     def javaSimpleName: Name = toDenot(sym).name // addModuleSuffix(simpleName.dropLocal)
-    def javaBinaryName: Name = toDenot(sym).fullNameSeparated('/') // addModuleSuffix(fullNameInternal('/'))
+    def javaBinaryName: Name = toDenot(sym).fullNameSeparated("/") // addModuleSuffix(fullNameInternal('/'))
     def javaClassName: String = toDenot(sym).fullName.toString// addModuleSuffix(fullNameInternal('.')).toString
     def name: Name = sym.name
     def rawname: Name = sym.name // todo ????

src/dotty/tools/dotc/core/NameOps.scala

@@ -150,7 +150,7 @@ object NameOps {
     /** The expanded name of `name` relative to given class `base`.
      */
     def expandedName(base: Symbol)(implicit ctx: Context): N =
-      expandedName(if (base is Flags.ExpandedName) base.name else base.fullNameSeparated('$'))
+      expandedName(if (base is Flags.ExpandedName) base.name else base.fullNameSeparated("$"))
 
     /** The expanded name of `name` relative to `basename` with given `separator`
      */

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

@@ -289,39 +289,40 @@ object SymDenotations {
     }
 
     /** The encoded full path name of this denotation, where outer names and inner names
-     *  are separated by `separator` characters.
+     *  are separated by `separator` strings.
      *  Never translates expansions of operators back to operator symbol.
-     *  Drops package objects. Represents terms in the owner chain by a simple `separator`.
+     *  Drops package objects. Represents terms in the owner chain by a simple `~`.
+     *  A separator "" means "flat name"; the real separator in this case is "$" and
+     *  enclosing packages do not form part of the name.
      */
-    def fullNameSeparated(separator: Char)(implicit ctx: Context): Name =
-      if (symbol == NoSymbol || owner == NoSymbol || owner.isEffectiveRoot) name
+    def fullNameSeparated(separator: String)(implicit ctx: Context): Name = {
+      var sep = separator
+      var stopAtPackage = false
+      if (sep.isEmpty) {
+        sep = "$"
+        stopAtPackage = true
+      }
+      if (symbol == NoSymbol ||
+          owner == NoSymbol ||
+          owner.isEffectiveRoot ||
+          stopAtPackage && owner.is(PackageClass)) name
       else {
-        var owner = this
-        var sep = ""
-        do {
-          owner = owner.owner
-          sep += separator
-        } while (!owner.isClass && !owner.isPackageObject)
-        val fn = owner.fullNameSeparated(separator) ++ sep ++ name
+        var encl = owner
+        while (!encl.isClass && !encl.isPackageObject) {
+          encl = encl.owner
+          sep += "~"
+        }
+        if (owner.is(ModuleClass) && sep == "$") sep = "" // duplicate scalac's behavior: don't write a double '$$' for module class members.
+        val fn = encl.fullNameSeparated(separator) ++ sep ++ name
         if (isType) fn.toTypeName else fn.toTermName
       }
+    }
 
     /** The encoded flat name of this denotation, where joined names are separated by `separator` characters. */
-    def flatName(separator: Char = '$')(implicit ctx: Context): Name =
-      if (symbol == NoSymbol || owner == NoSymbol || owner.isEffectiveRoot || (owner is PackageClass)) name
-      else {
-        var owner = this
-        var sep = ""
-        do {
-          owner = owner.owner
-          sep += separator
-        } while (!owner.isClass && !owner.isPackageObject)
-        val fn = owner.flatName(separator) ++ sep ++ name
-        if (isType) fn.toTypeName else fn.toTermName
-      }
+    def flatName(implicit ctx: Context): Name = fullNameSeparated("")
 
     /** `fullName` where `.' is the separator character */
-    def fullName(implicit ctx: Context): Name = fullNameSeparated('.')
+    def fullName(implicit ctx: Context): Name = fullNameSeparated(".")
 
     // ----- Tests -------------------------------------------------
 
@@ -1367,7 +1368,7 @@ object SymDenotations {
 
     /** Enter a symbol in given `scope` without potentially replacing the old copy. */
     def enterNoReplace(sym: Symbol, scope: MutableScope)(implicit ctx: Context): Unit = {
-      require((sym.denot.flagsUNSAFE is Private) ||  !(this is Frozen))
+      require((sym.denot.flagsUNSAFE is Private) || !(this is Frozen) || (unforcedDecls ne scope))
       scope.enter(sym)
 
       if (myMemberFingerPrint != FingerPrint.unknown)
@@ -1572,8 +1573,8 @@ object SymDenotations {
       }
     }
 
-    private[this] var fullNameCache: SimpleMap[Character, Name] = SimpleMap.Empty
-    override final def fullNameSeparated(separator: Char)(implicit ctx: Context): Name = {
+    private[this] var fullNameCache: SimpleMap[String, Name] = SimpleMap.Empty
+    override final def fullNameSeparated(separator: String)(implicit ctx: Context): Name = {
       val cached = fullNameCache(separator)
       if (cached != null) cached
       else {

src/dotty/tools/dotc/transform/Flatten.scala

@@ -6,7 +6,6 @@ import DenotTransformers.SymTransformer
 import Phases.Phase
 import Contexts.Context
 import Flags._
-import SymUtils._
 import SymDenotations.SymDenotation
 import collection.mutable
 import TreeTransforms.MiniPhaseTransform
@@ -19,7 +18,7 @@ class Flatten extends MiniPhaseTransform with SymTransformer { thisTransform =>
   def transformSym(ref: SymDenotation)(implicit ctx: Context) = {
     if (ref.isClass && !ref.is(Package) && !ref.owner.is(Package)) {
       ref.copySymDenotation(
-        name = ref.flatName(),
+        name = ref.flatName,
         owner = ref.enclosingPackageClass)
     }
     else ref

src/dotty/tools/dotc/transform/SymUtils.scala

@@ -85,9 +85,6 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def field(implicit ctx: Context): Symbol =
     self.owner.info.decl(self.asTerm.name.fieldName).suchThat(!_.is(Method)).symbol
 
-  /** `fullName` where `$' is the separator character */
-  def flatName(implicit ctx: Context): Name = self.flatName('$')
-
   def initializer(implicit ctx: Context): TermSymbol =
     self.owner.info.decl(InitializerName(self.asTerm.name)).symbol.asTerm