Allow multidenotations with same signature

Instead of issuing a merge error, allow multi-denotations with alternatives that have the same
signature.

Author: odersky

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

@@ -407,7 +407,7 @@ object Denotations {
       }
 
       /** Try to merge single-denotations. */
-      def mergeSingleDenot(denot1: SingleDenotation, denot2: SingleDenotation): SingleDenotation = {
+      def mergeSingleDenot(denot1: SingleDenotation, denot2: SingleDenotation): Denotation = {
         val info1 = denot1.info
         val info2 = denot2.info
         val sym1 = denot1.symbol
@@ -465,9 +465,10 @@ object Denotations {
           preferSym(sym1, sym2) &&
           info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely, checkClassInfo = false)
 
-        def handleDoubleDef =
+        def handleDoubleDef: Denotation =
           if (preferSym(sym1, sym2)) denot1
           else if (preferSym(sym2, sym1)) denot2
+          else if sym1.exists then MultiDenotation(denot1, denot2)
           else doubleDefError(denot1, denot2, pre)
 
         if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2

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

@@ -9,6 +9,7 @@ import dotty.tools.tasty.TastyBuffer._
 import ast.Trees._
 import ast.{untpd, tpd}
 import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, Flags._
+import Denotations.MultiDenotation
 import typer.Inliner
 import NameKinds._
 import StdNames.nme
@@ -381,10 +382,20 @@ class TreePickler(pickler: TastyPickler) {
                 pickleType(tp)
               }
             case _ =>
-              writeByte(if (name.isTypeName) SELECTtpt else SELECT)
               val sig = tree.tpe.signature
-              pickleNameAndSig(name, sig)
-              pickleTree(qual)
+              qual.tpe.nonPrivateMember(name).atSignature(sig) match
+                case d: MultiDenotation =>
+                  assert(tree.symbol.isTerm)
+                  writeByte(SELECTin)
+                  withLength {
+                    pickleNameAndSig(name, tree.symbol.signature)
+                    pickleTree(qual)
+                    pickleType(tree.symbol.owner.typeRef)
+                  }
+                case _ =>
+                  writeByte(if (name.isTypeName) SELECTtpt else SELECT)
+                  pickleNameAndSig(name, sig)
+                  pickleTree(qual)
           }
         case Apply(fun, args) =>
           if (fun.symbol eq defn.throwMethod) {

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

@@ -9,6 +9,7 @@ import Symbols._
 import Types._
 import Scopes._
 import SymDenotations._
+import Denotations._
 import Names._
 import NameOps._
 import StdNames._
@@ -1040,10 +1041,8 @@ class TreeUnpickler(reader: TastyReader,
         }
       }
 
-      def completeSelect(name: Name, sig: Signature): Select = {
-        val qual = readTerm()(ctx)
+      def makeSelect(qual: Tree, name: Name, denot: Denotation): Select =
         var qualType = qual.tpe.widenIfUnstable
-        val denot = accessibleDenot(qualType, name, sig)
         val owner = denot.symbol.maybeOwner
         if (owner.isPackageObject && qualType.termSymbol.is(Package))
           qualType = qualType.select(owner.sourceModule)
@@ -1052,7 +1051,11 @@ class TreeUnpickler(reader: TastyReader,
           case name: TermName => TermRef(qualType, name, denot)
         }
         ConstFold(untpd.Select(qual, name).withType(tpe))
-      }
+
+      def completeSelect(name: Name, sig: Signature): Select =
+        val qual = readTerm()(ctx)
+        val denot = accessibleDenot(qual.tpe.widenIfUnstable, name, sig)
+        makeSelect(qual, name, denot)
 
       def readQualId(): (untpd.Ident, TypeRef) =
         val qual = readTerm().asInstanceOf[untpd.Ident]
@@ -1165,6 +1168,16 @@ class TreeUnpickler(reader: TastyReader,
             case SELECTouter =>
               val levels = readNat()
               readTerm().outerSelect(levels, SkolemType(readType()))
+            case SELECTin =>
+              var sname = readName()
+              val qual = readTerm()
+              val owner = readType()
+              val prefix = qual.tpe.widenIfUnstable
+              sname match
+                case SignedName(name, sig) =>
+                  makeSelect(qual, name, owner.decl(name).atSignature(sig).asSeenFrom(prefix))
+                case name =>
+                  makeSelect(qual, name, owner.decl(name).asSeenFrom(prefix))
             case REPEATED =>
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)

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

@@ -1350,11 +1350,11 @@ trait Applications extends Compatibility {
     *  Module classes also inherit the relationship from their companions.
     */
   def compareOwner(sym1: Symbol, sym2: Symbol)(using Context): Int =
-    if (sym1 == sym2) 0
-    else if (sym1 isSubClass sym2) 1
-    else if (sym2 isSubClass sym1) -1
-    else if (sym2.is(Module)) compareOwner(sym1, sym2.companionClass)
-    else if (sym1.is(Module)) compareOwner(sym1.companionClass, sym2)
+    if sym1 == sym2 then 0
+    else if sym1.isSubClass(sym2) then 1
+    else if sym2.isSubClass(sym1) then -1
+    else if sym1.is(Module) && sym2.is(Module) then
+      compareOwner(sym1.companionClass, sym2.companionClass)
     else 0
 
   /** Compare to alternatives of an overloaded call or an implicit search.

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -75,6 +75,7 @@ Standard-Section: "ASTs" TopLevelStat*
   Term          = Path                                                             -- Paths represent both types and terms
                   IDENT                 NameRef Type                               -- Used when term ident’s type is not a TermRef
                   SELECT                possiblySigned_NameRef qual_Term           -- qual.name
+                  SELECTin       Length possiblySigned_NameRef qual_Term owner_Type -- qual.name, referring to a symbol declared in owner that has the given signature
                   QUALTHIS              typeIdent_Tree                             -- id.this, different from THIS in that it contains a qualifier ident with position.
                   NEW                   clsType_Term                               -- new cls
                   THROW                 throwableExpr_Term                         -- throw throwableExpr
@@ -452,6 +453,7 @@ object TastyFormat {
   final val ANNOTATION = 173
   final val TERMREFin = 174
   final val TYPEREFin = 175
+  final val SELECTin = 176
 
   final val METHODtype = 180
 
@@ -646,6 +648,7 @@ object TastyFormat {
     case SUPERtype => "SUPERtype"
     case TERMREFin => "TERMREFin"
     case TYPEREFin => "TYPEREFin"
+    case SELECTin => "SELECTin"
 
     case REFINEDtype => "REFINEDtype"
     case REFINEDtpt => "REFINEDtpt"
@@ -675,7 +678,7 @@ object TastyFormat {
    */
   def numRefs(tag: Int): Int = tag match {
     case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
-         SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
+         SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | SELECTin | HOLE => 1
     case RENAMED | PARAMtype => 2
     case POLYtype | TYPELAMBDAtype | METHODtype => -1
     case _ => 0

tests/neg/i1240b.scala

@@ -9,4 +9,4 @@ abstract class A[X] extends T[X] {
 trait U[X] extends T[X] {
   abstract override def foo(x: X): X = super.foo(x)
 }
-object Test extends A[String] with U[String] // error: accidental override // error: merge error
+object Test extends A[String] with U[String] // error: accidental override

tests/pos/i9050.scala

@@ -0,0 +1,6 @@
+
+object Foo {
+  val foo = scala.collection.mutable.ArrayBuffer.empty[Seq[Double]]
+  val bar = Seq.empty[Double]
+  foo.append(bar)
+}