Shadowed references

In TypeAssigner#ensureAccible we sometimes pick an inherited public
member as the denotation of a NamedType instead of an inaccessible
private one. The problem is that both are denotations for the same type,
which caused a noDoubleBindings assert failure. We now solve this problem
by creating a "shadowed" named type to hold the inherited member.

The shadowed named type is distinguished by its name, which reads

    (inherited)originalName

In the future, we should make this more robust by using a general
tagging scheme to create shadowed names.

Another fix is about import symbols. They are now referenced with
NonMemberTermRefs. With this fix, the test suite passes with no
double def violations.

Author: odersky

src/dotty/tools/dotc/config/Config.scala

@@ -13,13 +13,13 @@ object Config {
   final val checkConstraintsNonCyclic = true
 
   final val flagInstantiationToNothing = false
-  
+
   /** Enable noDoubleDef checking if option "-YnoDoubleDefs" is set.
     * The reason to have an option as well as the present global switch is
     * that the noDoubleDef checking is done in a hotspot, and we do not
     * want to incur the overhead of checking an option each time.
     */
-  final val checkTermRefs = false
+  final val checkNoDoubleBindings = true
 
   /** Throw an exception if a deep subtype recursion is detected */
   final val flagDeepSubTypeRecursions = true

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

@@ -50,6 +50,9 @@ object NameOps {
   implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
     import nme._
 
+    def likeTyped(n: Name): N =
+      (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
+
     def isConstructorName = name == CONSTRUCTOR || name == IMPLCLASS_CONSTRUCTOR
     def isExceptionResultName = name startsWith EXCEPTION_RESULT_PREFIX
     def isImplClassName = name endsWith IMPL_CLASS_SUFFIX
@@ -62,6 +65,8 @@ object NameOps {
     def isTraitSetterName = isSetterName && (name containsSlice TRAIT_SETTER_SEPARATOR)
     def isSingletonName = name endsWith SINGLETON_SUFFIX
     def isModuleClassName = name endsWith MODULE_SUFFIX
+    def isImportName = name startsWith IMPORT
+    def isInheritedName = name.head == '(' && name.startsWith(nme.INHERITED)
 
     def isModuleVarName(name: Name): Boolean =
       name.stripAnonNumberSuffix endsWith MODULE_VAR_SUFFIX
@@ -132,6 +137,10 @@ object NameOps {
       if (idx < 0) name else (name drop (idx + separator.length)).asInstanceOf[N]
     }
 
+    def inheritedName: N = likeTyped(nme.INHERITED ++ name)
+
+    def revertInherited: N = likeTyped(name.drop(nme.INHERITED.length))
+
     /** Translate a name into a list of simple TypeNames and TermNames.
      *  In all segments before the last, type/term is determined by whether
      *  the following separator char is '.' or '#'.  The last segment

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

@@ -100,6 +100,7 @@ object StdNames {
     val EXPAND_SEPARATOR: N           = "$$"
     val IMPL_CLASS_SUFFIX: N          = "$class"
     val IMPORT: N                     = "<import>"
+    val INHERITED: N                  = "(inherited)"  // tag to be used until we have proper name kinds
     val INTERPRETER_IMPORT_WRAPPER: N = "$iw"
     val INTERPRETER_LINE_PREFIX: N    = "line"
     val INTERPRETER_VAR_PREFIX: N     = "res"

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

@@ -684,7 +684,8 @@ object SymDenotations {
 
     /** The symbol, in class `inClass`, that is overridden by this denotation. */
     final def overriddenSymbol(inClass: ClassSymbol)(implicit ctx: Context): Symbol =
-      matchingSymbol(inClass, owner.thisType)
+      if ((this is Private) && (owner ne inClass)) NoSymbol
+      else matchingSymbol(inClass, owner.thisType)
 
     /** All symbols overriden by this denotation. */
     final def allOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] =
@@ -731,6 +732,9 @@ object SymDenotations {
     override def termRefWithSig(implicit ctx: Context): TermRef =
       TermRef.withSig(owner.thisType, name.asTermName, signature, this)
 
+    def nonMemberTermRef(implicit ctx: Context): TermRef =
+      TermRef.withNonMemberSym(owner.thisType, name.asTermName, symbol.asTerm)
+
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter
      */

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

@@ -656,15 +656,6 @@ object Types {
         if (res.exists) res else TypeRef(this, name, denot)
     }
 
-    /** The type <this . name> , reduced if possible, with given denotation if unreduced */
-    def selectNonMember(name: Name, denot: Denotation)(implicit ctx: Context): Type = name match {
-      case name: TermName =>
-        TermRef(this, name, denot)
-      case name: TypeName =>
-        val res = lookupRefined(name)
-        if (res.exists) res else TypeRef(this, name, denot)
-    }
-
     /** The type <this . name> with given symbol, reduced if possible */
     def select(sym: Symbol)(implicit ctx: Context): Type =
       if (sym.isTerm) TermRef(this, sym.asTerm)
@@ -1079,7 +1070,7 @@ object Types {
       }
 
     private[dotc] final def setDenot(denot: Denotation)(implicit ctx: Context): Unit = {
-      if (Config.checkTermRefs)
+      if (Config.checkNoDoubleBindings)
         if (ctx.settings.YnoDoubleBindings.value)
           checkSymAssign(denot.symbol)
       lastDenotation = denot
@@ -1095,7 +1086,7 @@ object Types {
       }
 
     private[dotc] final def setSym(sym: Symbol)(implicit ctx: Context): Unit = {
-      if (Config.checkTermRefs)
+      if (Config.checkNoDoubleBindings)
         if (ctx.settings.YnoDoubleBindings.value)
           checkSymAssign(sym)
       uncheckedSetSym(sym)
@@ -1111,7 +1102,9 @@ object Types {
       TermRef.withSig(prefix, name.asTermName, sig)
 
     protected def loadDenot(implicit ctx: Context) = {
-      val d = prefix.member(name)
+      val d =
+        if (name.isInheritedName) prefix.nonPrivateMember(name.revertInherited)
+        else prefix.member(name)
       if (d.exists || ctx.phaseId == FirstPhaseId)
         d
       else {// name has changed; try load in earlier phase and make current
@@ -1172,6 +1165,11 @@ object Types {
     protected def newLikeThis(prefix: Type)(implicit ctx: Context): NamedType =
       NamedType(prefix, name)
 
+    /** Create a NamedType of the same kind as this type, but with a new name.
+     */
+    final def shadowed(implicit ctx: Context): NamedType =
+      NamedType(prefix, name.inheritedName)
+
     override def equals(that: Any) = that match {
       case that: NamedType =>
         this.name == that.name &&

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

@@ -110,7 +110,7 @@ trait TypeAssigner {
           // an inherited non-private member with the same name and signature.
           val d2 = pre.nonPrivateMember(name)
           if (reallyExists(d2) && firstTry)
-            test(pre.select(name, d2), false)
+            test(tpe.shadowed.withDenot(d2), false)
           else {
             val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists)
             val what = alts match {
@@ -326,7 +326,7 @@ trait TypeAssigner {
     tree.withType(sym.typeRef)
 
   def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context) =
-    tree.withType(sym.termRef)
+    tree.withType(sym.nonMemberTermRef)
 
   def assignType(tree: untpd.Annotated, annot: Tree, arg: Tree)(implicit ctx: Context) =
     tree.withType(AnnotatedType(Annotation(annot), arg.tpe))

tests/pos/unions.scala

@@ -21,5 +21,12 @@ object unions {
   println(y.f)
   println(y.g(1.0))
 
+  class C {
+    private def foo = 0
+    class D extends C {
+      private def foo = 1
+      def test(cd: C | D, dc: D | C) = (cd.foo, dc.foo)
+    }
+  }
 
 }