Drop ShadowedName

Author: odersky

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

@@ -350,7 +350,6 @@ object NameKinds {
 
   val SuperAccessorName = new PrefixNameKind(SUPERACCESSOR, "super$")
   val InitializerName = new PrefixNameKind(INITIALIZER, "initial$")
-  val ShadowedName = new PrefixNameKind(SHADOWED, "(shadowed)")
   val ProtectedAccessorName = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
   val ProtectedSetterName = new PrefixNameKind(PROTECTEDSETTER, "protected$set") // dubious encoding, kept for Scala2 compatibility
   val AvoidClashName = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")

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

@@ -21,7 +21,6 @@ object StdNames {
     final val TRAIT_SETTER_SEPARATOR   = "$_setter_$"
     final val SUPER_PREFIX             = "super$"
     final val INITIALIZER_PREFIX       = "initial$"
-    final val SHADOWED_PREFIX          = "(shadowed)"
     final val AVOID_CLASH_SUFFIX       = "$_avoid_name_clash_$"
     final val MODULE_SUFFIX            = "$"
     final val NAME_JOIN                = "$"

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

@@ -7,7 +7,7 @@ import Symbols._
 import Flags._
 import Names._
 import StdNames._, NameOps._
-import NameKinds.{ShadowedName, SkolemName, SignedName}
+import NameKinds.{SkolemName, SignedName}
 import Scopes._
 import Constants._
 import Contexts._
@@ -1764,8 +1764,7 @@ object Types {
     def reloadDenot()(implicit ctx: Context) = setDenot(loadDenot)
 
     protected def asMemberOf(prefix: Type, allowPrivate: Boolean)(implicit ctx: Context): Denotation =
-      if (name.is(ShadowedName)) prefix.nonPrivateMember(name.exclude(ShadowedName))
-      else if (nameSpace != noNameSpace) nameSpace.findMember(name, prefix, EmptyFlags)
+      if (nameSpace != noNameSpace) nameSpace.findMember(name, prefix, EmptyFlags)
       else if (allowPrivate) prefix.member(name)
       else prefix.nonPrivateMember(name)
 
@@ -1918,31 +1917,10 @@ object Types {
       if (nameSpace == this.nameSpace) this
       else NamedType(prefix, designator.withNameSpace(nameSpace))
 
-    /** Create a NamedType of the same kind as this type, but with a "inherited name".
-     *  This is necessary to in situations like the following:
-     *
-     *    class B { def m: T1 }
-     *    class C extends B { private def m: T2; ... C.m }
-     *    object C extends C
-     *    object X { ... C.m }
-     *
-     *  The two references of C.m in class C and object X refer to different
-     *  definitions: The one in C refers to C#m whereas the one in X refers to B#m.
-     *  But the type C.m must have only one denotation, so it can't refer to two
-     *  members depending on context.
-     *
-     *  In situations like this, the reference in X would get the type
-     *  `<C.m>.shadowed` to make clear that we mean the inherited member, not
-     *  the private one.
-     *
-     *  Note: An alternative, possibly more robust scheme would be to give
-     *  private members special names. A private definition would have a special
-     *  name (say m' in the example above), but would be entered in its enclosing
-     *  under both private and public names, so it could still be found by looking up
-     *  the public name.
+    /** Create a NamedType of the same kind as this type, but without a namespace
      */
-    def shadowed(implicit ctx: Context): NamedType =
-	    (designator: Designator) match { // Dotty deviation: need the widening
+    def withoutNameSpace(implicit ctx: Context): NamedType =
+      (designator: Designator) match { // Dotty deviation: need the widening
         case LocalName(underlying, _) => NamedType(prefix, underlying)
         case _ => this
       }
@@ -2018,8 +1996,8 @@ object Types {
         fixDenot(TermRef(prefix, designator1), prefix)
     }
 
-    override def shadowed(implicit ctx: Context): NamedType =
-      fixDenot(super.shadowed.asInstanceOf[TermRef], prefix)
+    override def withoutNameSpace(implicit ctx: Context): NamedType =
+      fixDenot(super.withoutNameSpace.asInstanceOf[TermRef], prefix)
   }
 
   abstract case class TypeRef(override val prefix: Type, designator: TypeDesignator) extends NamedType {

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

@@ -249,7 +249,6 @@ object TastyFormat {
   final val PROTECTEDACCESSOR = 21
   final val PROTECTEDSETTER = 22
   final val INITIALIZER = 23
-  final val SHADOWED = 24
   final val AVOIDCLASH = 30
   final val DIRECT = 31
   final val FIELD = 32
@@ -468,7 +467,6 @@ object TastyFormat {
     case PROTECTEDACCESSOR => "PROTECTEDACCESSOR"
     case PROTECTEDSETTER => "PROTECTEDSETTER"
     case INITIALIZER => "INITIALIZER"
-    case SHADOWED => "SHADOWED"
     case AVOIDCLASH => "AVOIDCLASH"
     case DIRECT => "DIRECT"
     case FIELD => "FIELD"

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

@@ -333,14 +333,10 @@ class TreePickler(pickler: TastyPickler) {
           }
         case Select(qual, name) =>
           writeByte(if (name.isTypeName) SELECTtpt else SELECT)
-          val realName = tree.tpe match {
-            case tp: NamedType if tp.name.is(ShadowedName) => tp.name
-            case _ => name
-          }
           val sig = tree.tpe.signature
           pickleName(
-            if (name.isTypeName || sig == Signature.NotAMethod) realName
-            else SignedName(realName.toTermName, sig))
+            if (name.isTypeName || sig == Signature.NotAMethod) name
+            else SignedName(name.toTermName, sig))
           pickleTree(qual)
         case Apply(fun, args) =>
           writeByte(APPLY)

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

@@ -865,8 +865,7 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
         val localCtx =
           if (name == nme.CONSTRUCTOR) ctx.addMode(Mode.InSuperCall) else ctx
         val qual = readTerm()(localCtx)
-        val unshadowed = name.exclude(ShadowedName)
-        untpd.Select(qual, unshadowed).withType(tpf(qual.tpe.widenIfUnstable))
+        untpd.Select(qual, name).withType(tpf(qual.tpe.widenIfUnstable))
       }
 
       def readQualId(): (untpd.Ident, TypeRef) = {

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -11,7 +11,6 @@ import core.Types._
 import core.Names._
 import core.StdNames._
 import core.NameOps._
-import core.NameKinds.ShadowedName
 import core.Decorators._
 import core.Constants._
 import core.Definitions._
@@ -385,14 +384,8 @@ object Erasure {
       val sym = if (owner eq origSym.owner) origSym else owner.info.decl(origSym.name).symbol
       assert(sym.exists, origSym.showLocated)
 
-      def select(qual: Tree, sym: Symbol): Tree = {
-        val name = tree.typeOpt match {
-          case tp: NamedType if tp.name.is(ShadowedName) => sym.name.derived(ShadowedName)
-          case _ => sym.name
-        }
-        untpd.cpy.Select(tree)(qual, sym.name)
-          .withType(NamedType(qual.tpe, sym))
-      }
+      def select(qual: Tree, sym: Symbol): Tree =
+        untpd.cpy.Select(tree)(qual, sym.name).withType(NamedType(qual.tpe, sym))
 
       def selectArrayMember(qual: Tree, erasedPre: Type): Tree =
         if (erasedPre isRef defn.ObjectClass)

compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala

@@ -72,7 +72,7 @@ class ParamForwarding(thisTransformer: DenotTransformer) {
                     if (alias.owner != currentClass.superClass)
                       // need to use shadowed in order not to accidentally address an
                       // intervening private forwarder in the superclass
-                      superAcc = superAcc.withType(superAcc.tpe.asInstanceOf[TermRef].shadowed)
+                      superAcc = superAcc.withType(superAcc.tpe.asInstanceOf[TermRef].withoutNameSpace)
                     typr.println(i"adding param forwarder $superAcc")
                     DefDef(sym, superAcc.ensureConforms(sym.info.widen))
                   }

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -188,8 +188,7 @@ trait TypeAssigner {
           // an inherited non-private member with the same name and signature.
           val d2 = pre.nonPrivateMember(name)
           if (reallyExists(d2) && firstTry)
-            // test(NamedType(pre, name, d2), false)
-            test(tpe.shadowed.withDenot(d2), false)
+            test(tpe.withoutNameSpace.withDenot(d2), false)
           else if (pre.derivesFrom(defn.DynamicClass)) {
             TryDynamicCallType
           } else {