Make signatures use fully qualified names.

Needed a refactoring of fullname to be able to refer to fullName without passing a context explicitly.

Also, relax isAccessible check. The prefix condition for protected access need not hold for constructors.

3 files changed, 10 insertions, 8 deletions

diff --git a/src/dotty/tools/dotc/core/NameOps.scala b/src/dotty/tools/dotc/core/NameOps.scala
index cd37c6086..de9bc0e5e 100644
--- a/src/dotty/tools/dotc/core/NameOps.scala
+++ b/src/dotty/tools/dotc/core/NameOps.scala
@@ -123,7 +123,7 @@ object NameOps {
     /** The expanded name of `name` relative to this class `base` with given `separator`
      */
     def expandedName(base: Symbol, separator: Name = nme.EXPAND_SEPARATOR)(implicit ctx: Context): N = {
-      val prefix = if (base is Flags.ExpandedName) base.name else base.fullName('$')
+      val prefix = if (base is Flags.ExpandedName) base.name else base.fullNameSeparated('$')
       name.fromName(prefix ++ separator ++ name).asInstanceOf[N]
     }
 
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 9da918867..40f155ed9 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -229,7 +229,7 @@ object SymDenotations {
      *  Never translates expansions of operators back to operator symbol.
      *  Drops package objects. Represents terms in the owner chain by a simple `separator`.
      */
-    def fullName(separator: Char)(implicit ctx: Context): Name =
+    def fullNameSeparated(separator: Char)(implicit ctx: Context): Name =
       if (symbol == NoSymbol || owner == NoSymbol || owner.isEffectiveRoot) name
       else {
         var owner = this
@@ -238,11 +238,12 @@ object SymDenotations {
           owner = owner.owner
           sep += separator
         } while (!owner.isClass)
-        owner.skipPackageObject.fullName(separator) ++ sep ++ name
+        val fn = owner.skipPackageObject.fullNameSeparated(separator) ++ sep ++ name
+        if (isType) fn.toTypeName else fn.toTermName
       }
 
     /** `fullName` where `.' is the separator character */
-    def fullName(implicit ctx: Context): Name = fullName('.')
+    def fullName(implicit ctx: Context): Name = fullNameSeparated('.')
 
     // ----- Tests -------------------------------------------------
 
@@ -426,6 +427,7 @@ object SymDenotations {
         else if (
           !(  isType // allow accesses to types from arbitrary subclasses fixes #4737
            || pre.baseType(cls).exists
+           || isConstructor
            || (owner is ModuleClass) // don't perform this check for static members
            ))
           fail(
@@ -1092,11 +1094,11 @@ object SymDenotations {
     }
 
     private[this] var fullNameCache: SimpleMap[Character, Name] = SimpleMap.Empty
-    override final def fullName(separator: Char)(implicit ctx: Context): Name = {
+    override final def fullNameSeparated(separator: Char)(implicit ctx: Context): Name = {
       val cached = fullNameCache(separator)
       if (cached != null) cached
       else {
-        val fn = super.fullName(separator)
+        val fn = super.fullNameSeparated(separator)
         fullNameCache = fullNameCache.updated(separator, fn)
         fn
       }
diff --git a/src/dotty/tools/dotc/core/transform/Erasure.scala b/src/dotty/tools/dotc/core/transform/Erasure.scala
index 9b118dfe7..34f339d9a 100644
--- a/src/dotty/tools/dotc/core/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/core/transform/Erasure.scala
@@ -107,8 +107,8 @@ object Erasure {
       val sym = tp.symbol
       if (sym.isClass)
         /*if (sym.isDerivedValueClass) eraseDerivedValueClassRef(tref)
-        else */if (sym.owner is Package) normalizeClass(sym.asClass).name
-        else sym.asClass.name
+        else */if (sym.owner is Package) normalizeClass(sym.asClass).fullName.asTypeName
+        else sym.asClass.fullName.asTypeName
       else sigName(tp.info)
     case tp: RefinedType =>
       val parent = tp.parent