Merge pull request #9063 from dotty-staging/fix-#9050

Fix #9050: Allow multidenotations with same signature

Author: odersky

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -384,7 +384,8 @@ class CommunityBuildTest:
   @Test def scodecBits = projects.scodecBits.run()
   @Test def scodec = projects.scodec.run()
   @Test def scalaParserCombinators = projects.scalaParserCombinators.run()
-  @Test def dottyCpsAsync = projects.dottyCpsAsync.run()
+  // blocked on #9074
+  //@Test def dottyCpsAsync = projects.dottyCpsAsync.run()
   @Test def scalaz = projects.scalaz.run()
   @Test def endpoints = projects.endpoints.run()
 end CommunityBuildTest

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

@@ -922,8 +922,8 @@ object SymDenotations {
         else true
       }
 
-      if (pre eq NoPrefix) true
-      else if (isAbsent()) false
+      if pre eq NoPrefix then true
+      else if isAbsent() then false
       else {
         val boundary = accessBoundary(owner)
 
@@ -2133,7 +2133,7 @@ object SymDenotations {
       var names = Set[Name]()
       def maybeAdd(name: Name) = if (keepOnly(thisType, name)) names += name
       try {
-        for (p <- classParents)
+        for (p <- classParents if p.classSymbol.isClass)
           for (name <- p.classSymbol.asClass.memberNames(keepOnly))
             maybeAdd(name)
         val ownSyms =

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

@@ -2047,16 +2047,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  instantiated TypeVars are dereferenced and annotations are stripped.
    *  Finally, refined types with the same refined name are
    *  opportunistically merged.
-   *
-   *  Sometimes, the conjunction of two types cannot be formed because
-   *  the types are in conflict of each other. In particular:
-   *
-   *    1. Two different class types are conflicting.
-   *    2. A class type conflicts with a type bounds that does not include the class reference.
-   *    3. Two method or poly types with different (type) parameters but the same
-   *       signature are conflicting
-   *
-   *  In these cases, a MergeError is thrown.
    */
   final def andType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type =
     andTypeGen(tp1, tp2, AndType(_, _), isErased = isErased)
@@ -2070,10 +2060,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
    *  ExprType, LambdaType). Also, when forming an `|`,
    *  instantiated TypeVars are dereferenced and annotations are stripped.
    *
-   *  Sometimes, the disjunction of two types cannot be formed because
-   *  the types are in conflict of each other. (@see `andType` for an enumeration
-   *  of these cases). In cases of conflict a `MergeError` is raised.
-   *
    *  @param isErased Apply erasure semantics. If erased is true, instead of creating
    *                  an OrType, the lub will be computed using TypeCreator#erasedLub.
    */
@@ -2139,13 +2125,11 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
       // gives =:= types), but it keeps the type smaller.
       tp2 match {
         case tp2: RefinedType if tp1.refinedName == tp2.refinedName =>
-          try {
-            val jointInfo = Denotations.infoMeet(tp1.refinedInfo, tp2.refinedInfo, NoSymbol, NoSymbol, safeIntersection = false)
+          val jointInfo = Denotations.infoMeet(tp1.refinedInfo, tp2.refinedInfo, safeIntersection = false)
+          if jointInfo.exists then
             tp1.derivedRefinedType(tp1.parent & tp2.parent, tp1.refinedName, jointInfo)
-          }
-          catch {
-            case ex: MergeError => NoType
-          }
+          else
+            NoType
         case _ =>
           NoType
       }

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

@@ -163,32 +163,3 @@ object CyclicReference {
   }
 }
 
-class MergeError(val sym1: Symbol, val sym2: Symbol, val tp1: Type, val tp2: Type, prefix: Type) extends TypeError {
-
-  private def showSymbol(sym: Symbol)(implicit ctx: Context): String =
-    if (sym.exists) sym.showLocated else "[unknown]"
-
-  private def showType(tp: Type)(implicit ctx: Context) = tp match {
-    case ClassInfo(_, cls, _, _, _) => cls.showLocated
-    case _ => tp.show
-  }
-
-  protected def addendum(implicit ctx: Context): String =
-    if (prefix `eq` NoPrefix) ""
-    else {
-      val owner = prefix match {
-        case prefix: ThisType => prefix.cls.show
-        case prefix: TermRef => prefix.symbol.show
-        case _ => i"type $prefix"
-      }
-      s"\nas members of $owner"
-    }
-
-  override def produceMessage(implicit ctx: Context): Message = {
-    if (ctx.debug) printStackTrace()
-    i"""cannot merge
-       |  ${showSymbol(sym1)} of type ${showType(tp1)}  and
-       |  ${showSymbol(sym2)} of type ${showType(tp2)}$addendum
-       """
-  }
-}

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

@@ -675,7 +675,7 @@ object Types {
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         }
         else
-          val joint = pdenot & (
+          val joint = pdenot.meet(
             new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre),
             pre,
             safeIntersection = ctx.base.pendingMemberSearches.contains(name))
@@ -726,7 +726,7 @@ object Types {
       }
 
       def goAnd(l: Type, r: Type) =
-        go(l) & (go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
+        go(l).meet(go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
 
       def goOr(tp: OrType) = tp match {
         case OrUncheckedNull(tp1) =>

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

@@ -82,7 +82,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
               printName(); printName()
             case VALDEF | DEFDEF | TYPEDEF | TYPEPARAM | PARAM | NAMEDARG | BIND =>
               printName(); printTrees()
-            case REFINEDtype | TERMREFin | TYPEREFin =>
+            case REFINEDtype | TERMREFin | TYPEREFin | SELECTin =>
               printName(); printTree(); printTrees()
             case RETURN | HOLE =>
               printNat(); printTrees()

compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.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
@@ -173,22 +174,20 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: NamedType =>
       val sym = tpe.symbol
       def pickleExternalRef(sym: Symbol) = {
-        def pickleCore() = {
-          pickleNameAndSig(sym.name, tpe.signature)
-          pickleType(tpe.prefix)
-        }
         val isShadowedRef =
           sym.isClass && tpe.prefix.member(sym.name).symbol != sym
         if (sym.is(Flags.Private) || isShadowedRef) {
           writeByte(if (tpe.isType) TYPEREFin else TERMREFin)
           withLength {
-            pickleCore()
+            pickleNameAndSig(sym.name, tpe.symbol.signature)
+            pickleType(tpe.prefix)
             pickleType(sym.owner.typeRef)
           }
         }
         else {
           writeByte(if (tpe.isType) TYPEREF else TERMREF)
-          pickleCore()
+          pickleNameAndSig(sym.name, tpe.signature)
+          pickleType(tpe.prefix)
         }
       }
       if (sym.is(Flags.Package)) {
@@ -381,10 +380,23 @@ class TreePickler(pickler: TastyPickler) {
                 pickleType(tp)
               }
             case _ =>
-              writeByte(if (name.isTypeName) SELECTtpt else SELECT)
               val sig = tree.tpe.signature
-              pickleNameAndSig(name, sig)
-              pickleTree(qual)
+              val isAmbiguous =
+                sig != Signature.NotAMethod
+                && qual.tpe.nonPrivateMember(name).match
+                  case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
+                  case _ => false
+              if isAmbiguous then
+                writeByte(SELECTin)
+                withLength {
+                  pickleNameAndSig(name, tree.symbol.signature)
+                  pickleTree(qual)
+                  pickleType(tree.symbol.owner.typeRef)
+                }
+              else
+                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/TreePickler.scala

@@ -9,6 +9,7 @@ import Symbols._
 import Types._
 import Scopes._
 import SymDenotations._
+import Denotations._
 import Names._
 import NameOps._
 import StdNames._
@@ -330,12 +331,12 @@ class TreeUnpickler(reader: TastyReader,
             case TERMREFin =>
               var sname = readName()
               val prefix = readType()
-              val space = readType()
+              val owner = readType()
               sname match {
                 case SignedName(name, sig) =>
-                  TermRef(prefix, name, space.decl(name).asSeenFrom(prefix).atSignature(sig))
+                  TermRef(prefix, name, owner.decl(name).atSignature(sig).asSeenFrom(prefix))
                 case name =>
-                  TermRef(prefix, name, space.decl(name).asSeenFrom(prefix))
+                  TermRef(prefix, name, owner.decl(name).asSeenFrom(prefix))
               }
             case TYPEREFin =>
               val name = readName().toTypeName
@@ -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,18 @@ 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()
+              def select(name: Name, denot: Denotation) =
+                val prefix = ctx.typeAssigner.maybeSkolemizePrefix(qual.tpe.widenIfUnstable, name)
+                makeSelect(qual, name, denot.asSeenFrom(prefix))
+              sname match
+                case SignedName(name, sig) =>
+                  select(name, owner.decl(name).atSignature(sig))
+                case name =>
+                  select(name, owner.decl(name))
             case REPEATED =>
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)

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

@@ -425,22 +425,10 @@ object RefChecks {
           }*/
     }
 
-    try {
-      val opc = new OverridingPairs.Cursor(clazz)
-      while (opc.hasNext) {
-        checkOverride(opc.overriding, opc.overridden)
-        opc.next()
-      }
-    }
-    catch {
-      case ex: MergeError =>
-        val addendum = ex.tp1 match {
-          case tp1: ClassInfo =>
-            "\n(Note that having same-named member classes in types of a mixin composition is no longer allowed)"
-          case _ => ""
-        }
-        ctx.error(ex.getMessage + addendum, clazz.sourcePos)
-    }
+    val opc = new OverridingPairs.Cursor(clazz)
+    while opc.hasNext do
+      checkOverride(opc.overriding, opc.overridden)
+      opc.next()
     printMixinOverrideErrors()
 
     // Verifying a concrete class has nothing unimplemented.