From 46c3e43522bbf65644a685e6d77083d91b4b322c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Wed, 27 May 2020 23:37:34 +0200
Subject: [PATCH 01/20] Allow multidenotations with same signature

Instead of issuing a merge error, allow multi-denotations with alternatives that have the same
signature.
---
 .../dotty/tools/dotc/core/Denotations.scala   |  5 +++--
 .../tools/dotc/core/tasty/TreePickler.scala   | 17 ++++++++++++---
 .../tools/dotc/core/tasty/TreeUnpickler.scala | 21 +++++++++++++++----
 tasty/src/dotty/tools/tasty/TastyFormat.scala |  5 ++++-
 tests/neg/i1240b.scala                        |  2 +-
 tests/pos/i9050.scala                         |  6 ++++++
 6 files changed, 45 insertions(+), 11 deletions(-)
 create mode 100644 tests/pos/i9050.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 9a0ffb017975..8cc3d716e6a9 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/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
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 95dbaeb10267..0417fce382f6 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/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) {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index f8adb6426a7d..fbf123f168cc 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/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)
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 96ded6aa7df9..92aa177bff45 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/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
diff --git a/tests/neg/i1240b.scala b/tests/neg/i1240b.scala
index 8f2ec81d4702..2d23db61470b 100644
--- a/tests/neg/i1240b.scala
+++ b/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
diff --git a/tests/pos/i9050.scala b/tests/pos/i9050.scala
new file mode 100644
index 000000000000..e538ec5d1cd3
--- /dev/null
+++ b/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)
+}
\ No newline at end of file

From 4f7a02e7be0dab682701fcd0d326c8b0421a1795 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 12:31:52 +0200
Subject: [PATCH 02/20] Some small optimizations

---
 .../tools/dotc/core/tasty/TreePickler.scala   | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 0417fce382f6..41e15354f51e 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -383,19 +383,22 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              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)
+              val isAmbiguous =
+                qual.tpe.nonPrivateMember(name).atSignature(sig) match
+                  case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
+                  case _ => false
+              if isAmbiguous then
+                assert(tree.symbol.isTerm)
+                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) {

From f31cdf04e355c4b6e3c6d080ce461fad33016cca Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 12:35:34 +0200
Subject: [PATCH 03/20] Restrict test for choosing SELECTin

Test only for methods. Others cannot get signature clashes
through asSeenFrom. That is, if they clash after asSeenFrom,
they already clash before.
---
 compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 41e15354f51e..1d6130e22113 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -384,11 +384,11 @@ class TreePickler(pickler: TastyPickler) {
             case _ =>
               val sig = tree.tpe.signature
               val isAmbiguous =
-                qual.tpe.nonPrivateMember(name).atSignature(sig) match
+                sig != Signature.NotAMethod
+                && qual.tpe.nonPrivateMember(name).match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
               if isAmbiguous then
-                assert(tree.symbol.isTerm)
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature)

From 4723f163309a4f90dea3b316634a087ac889261a Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 15:31:16 +0200
Subject: [PATCH 04/20] Use simpler disambiguation criterion in case of double
 defs

---
 .../dotty/tools/dotc/core/Denotations.scala   | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 8cc3d716e6a9..057fc34e3d65 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -449,16 +449,19 @@ object Denotations {
          *   - minimizes raising of doubleDef errors
          */
         def preferSym(sym1: Symbol, sym2: Symbol) =
-          sym1.eq(sym2) ||
-          sym1.exists &&
-            (!sym2.exists ||
-              sym1.isAsConcrete(sym2) &&
-              (!sym2.isAsConcrete(sym1) ||
-                precedes(sym1.owner, sym2.owner) ||
-                accessBoundary(sym2).isProperlyContainedIn(accessBoundary(sym1)) ||
-                sym2.is(Bridge) && !sym1.is(Bridge) ||
-                sym1.is(Method) && !sym2.is(Method)) ||
-              sym1.info.isErroneous)
+          sym1.eq(sym2)
+          || sym1.exists
+             && (!sym2.exists
+                || sym1.isAsConcrete(sym2)
+                   && (!sym2.isAsConcrete(sym1)
+                      || precedes(sym1.owner, sym2.owner)
+                      || accessBoundary(sym2).isProperlyContainedIn(accessBoundary(sym1))
+                      || sym2.is(Bridge) && !sym1.is(Bridge)
+                      || sym1.is(Method) && !sym2.is(Method))
+                || sym1.info.isErroneous)
+
+        def preferSymSimple(sym1: Symbol, sym2: Symbol) =
+          sym1.is(Method) && !sym2.is(Method) || sym1.info.isErroneous
 
         /** Sym preference provided types also override */
         def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
@@ -466,10 +469,9 @@ object Denotations {
           info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely, checkClassInfo = false)
 
         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 preferSymSimple(sym1, sym2) then denot1
+          else if preferSymSimple(sym2, sym1) then denot2
+          else MultiDenotation(denot1, denot2)
 
         if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
         else {

From dbc1e95bd32833bec6494685b817ad5a3e16e916 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 15:38:18 +0200
Subject: [PATCH 05/20] Don't throw merge errors when infos conflict

Wait until overloading resolution instead.
---
 .../dotty/tools/dotc/core/Denotations.scala   | 34 ++++++++-----------
 tests/neg/i7425.scala                         |  4 +--
 2 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 057fc34e3d65..05802272a653 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/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): Denotation = {
+      def mergeSingleDenot(denot1: SingleDenotation, denot2: SingleDenotation): Denotation =
         val info1 = denot1.info
         val info2 = denot2.info
         val sym1 = denot1.symbol
@@ -474,34 +474,28 @@ object Denotations {
           else MultiDenotation(denot1, denot2)
 
         if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
-        else {
+        else
           val sym1Accessible = sym1.isAccessibleFrom(pre)
           if (sym1Accessible && prefer(sym1, sym2, info1, info2)) denot1
           else if (sym1Accessible && sym2.exists && !sym2Accessible) denot1
           else if (sym2Accessible && sym1.exists && !sym1Accessible) denot2
           else if (isDoubleDef(sym1, sym2)) handleDoubleDef
-          else {
+          else
             val sym =
               if (preferSym(sym2, sym1)) sym2
               else sym1
-            val jointInfo =
-              try infoMeet(info1, info2, sym1, sym2, safeIntersection)
-              catch {
-                case ex: MergeError =>
-                  // TODO: this picks one type over the other whereas it might be better
-                  // to return a MultiDenotation instead. But doing so would affect lots of
-                  // things, starting with the return type of this method.
-                  if (preferSym(sym2, sym1)) info2
-                  else if (preferSym(sym1, sym2)) info1
-                  else if (pre.widen.classSymbol.is(Scala2x) || migrateTo3)
-                    info1 // follow Scala2 linearization -
+            def jointRef(jointInfo: Type) =
+              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+            try jointRef(infoMeet(info1, info2, sym1, sym2, safeIntersection))
+            catch case ex: MergeError =>
+              if preferSymSimple(sym2, sym1) then jointRef(info2)
+              else if preferSymSimple(sym1, sym2) then jointRef(info1)
+              else if pre.widen.classSymbol.is(Scala2x) || migrateTo3 then
+                jointRef(info1)
+                  // follow Scala2 linearization -
                   // compare with way merge is performed in SymDenotation#computeMembersNamed
-                  else throw new MergeError(ex.sym1, ex.sym2, ex.tp1, ex.tp2, pre)
-              }
-            new JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
-          }
-        }
-      }
+              else MultiDenotation(denot1, denot2)
+      end mergeSingleDenot
 
       if (this eq that) this
       else if (!this.exists) that
diff --git a/tests/neg/i7425.scala b/tests/neg/i7425.scala
index 24481ea375f4..961b3f0f855a 100644
--- a/tests/neg/i7425.scala
+++ b/tests/neg/i7425.scala
@@ -2,11 +2,11 @@ class C { def f: Int = 0 }
 
 trait D { def f(): Int = 0 }
 
-def foo1(x: C & D) = x.f // error: method f must be called with argument
+def foo1(x: C & D) = x.f // ok
 def foo2(x: C | D) = x.f // error: value f is not a member of C | D
 def foo3(x: D & C) = x.f // ok
 def foo4(x: D | C) = x.f // error: value f is not a member of D | C
 def foo5(x: C & D) = x.f() // ok
 def foo6(x: C | D) = x.f() // error: value f is not a member of C | D
-def foo7(x: D & C) = x.f() // error: method f in class C does not take parameters
+def foo7(x: D & C) = x.f() // ok
 def foo8(x: D | C) = x.f() // error: value f is not a member of D | C

From b6a5b4a66b41a4855c774f634b5d884ab7c0efbd Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 16:05:30 +0200
Subject: [PATCH 06/20] Polishings

---
 .../dotty/tools/dotc/core/Denotations.scala   | 25 +++++++++++++------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 05802272a653..417236bef341 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -468,9 +468,22 @@ object Denotations {
           preferSym(sym1, sym2) &&
           info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely, checkClassInfo = false)
 
+        /** `sym1` comes before `sym2` in the ranking
+         *    1. Non-bridge methods
+         *    2. non-methods
+         *    3. bridges
+         *    4. NoSymbol
+         */
+        def preferMethod(sym1: Symbol, sym2: Symbol): Boolean =
+          sym1.exists &&
+            (!sym2.exists
+            || sym2.is(Bridge) && !sym1.is(Bridge)
+            || sym1.is(Method) && !sym2.is(Method)
+            || sym1.info.isErroneous)
+
         def handleDoubleDef: Denotation =
-          if preferSymSimple(sym1, sym2) then denot1
-          else if preferSymSimple(sym2, sym1) then denot2
+          if preferMethod(sym1, sym2) then denot1
+          else if preferMethod(sym2, sym1) then denot2
           else MultiDenotation(denot1, denot2)
 
         if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
@@ -481,15 +494,13 @@ object Denotations {
           else if (sym2Accessible && sym1.exists && !sym1Accessible) denot2
           else if (isDoubleDef(sym1, sym2)) handleDoubleDef
           else
-            val sym =
-              if (preferSym(sym2, sym1)) sym2
-              else sym1
+            val sym = if preferSym(sym2, sym1) then sym2 else sym1
             def jointRef(jointInfo: Type) =
               JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
             try jointRef(infoMeet(info1, info2, sym1, sym2, safeIntersection))
             catch case ex: MergeError =>
-              if preferSymSimple(sym2, sym1) then jointRef(info2)
-              else if preferSymSimple(sym1, sym2) then jointRef(info1)
+              if preferMethod(sym2, sym1) then jointRef(info2)
+              else if preferMethod(sym1, sym2) then jointRef(info1)
               else if pre.widen.classSymbol.is(Scala2x) || migrateTo3 then
                 jointRef(info1)
                   // follow Scala2 linearization -

From 659b18bd190e8a7283e03db85bad367891908a14 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 17:23:43 +0200
Subject: [PATCH 07/20] Drop special handling of Scala 2 members

---
 .../dotty/tools/dotc/core/Denotations.scala   | 55 ++++++++++---------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 417236bef341..f85f7636ef19 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -19,6 +19,7 @@ import printing.Printer
 import io.AbstractFile
 import config.Feature.migrateTo3
 import config.Config
+import config.Printers.overload
 import util.common._
 import typer.ProtoTypes.NoViewsAllowed
 import collection.mutable.ListBuffer
@@ -460,31 +461,40 @@ object Denotations {
                       || sym1.is(Method) && !sym2.is(Method))
                 || sym1.info.isErroneous)
 
-        def preferSymSimple(sym1: Symbol, sym2: Symbol) =
-          sym1.is(Method) && !sym2.is(Method) || sym1.info.isErroneous
-
         /** Sym preference provided types also override */
         def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
           preferSym(sym1, sym2) &&
           info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely, checkClassInfo = false)
 
-        /** `sym1` comes before `sym2` in the ranking
+        /** Handle conflict where we have either definitions coming from the same class
+         *  that have matching signatures as seen from the current prefix, or we have
+         *  definitions from different classes that have the same signature but
+         *  conflicting infos. In these cases, do a last minute disambiguation
+         *  by picking one alternative according to the ranking
+         *
          *    1. Non-bridge methods
          *    2. non-methods
          *    3. bridges
          *    4. NoSymbol
+         *
+         *  If that fails, return a MultiDenotation with both alternatives
+         *  and rely on overloading resolution to pick one of them.
          */
-        def preferMethod(sym1: Symbol, sym2: Symbol): Boolean =
-          sym1.exists &&
-            (!sym2.exists
-            || sym2.is(Bridge) && !sym1.is(Bridge)
-            || sym1.is(Method) && !sym2.is(Method)
-            || sym1.info.isErroneous)
-
-        def handleDoubleDef: Denotation =
+        def handleConflict: Denotation =
+
+          def preferMethod(sym1: Symbol, sym2: Symbol): Boolean =
+            sym1.exists &&
+              (!sym2.exists
+              || sym2.is(Bridge) && !sym1.is(Bridge)
+              || sym1.is(Method) && !sym2.is(Method)
+              || sym1.info.isErroneous)
+
           if preferMethod(sym1, sym2) then denot1
           else if preferMethod(sym2, sym1) then denot2
-          else MultiDenotation(denot1, denot2)
+          else
+            overload.println(i"overloaded with same signature: ${sym1.showLocated}: $info1 / ${sym2.showLocated}: $info2")
+            MultiDenotation(denot1, denot2)
+        end handleConflict
 
         if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
         else
@@ -492,20 +502,13 @@ object Denotations {
           if (sym1Accessible && prefer(sym1, sym2, info1, info2)) denot1
           else if (sym1Accessible && sym2.exists && !sym2Accessible) denot1
           else if (sym2Accessible && sym1.exists && !sym1Accessible) denot2
-          else if (isDoubleDef(sym1, sym2)) handleDoubleDef
-          else
+          else if isDoubleDef(sym1, sym2) then handleConflict
+          else try
             val sym = if preferSym(sym2, sym1) then sym2 else sym1
-            def jointRef(jointInfo: Type) =
-              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
-            try jointRef(infoMeet(info1, info2, sym1, sym2, safeIntersection))
-            catch case ex: MergeError =>
-              if preferMethod(sym2, sym1) then jointRef(info2)
-              else if preferMethod(sym1, sym2) then jointRef(info1)
-              else if pre.widen.classSymbol.is(Scala2x) || migrateTo3 then
-                jointRef(info1)
-                  // follow Scala2 linearization -
-                  // compare with way merge is performed in SymDenotation#computeMembersNamed
-              else MultiDenotation(denot1, denot2)
+            val jointInfo = infoMeet(info1, info2, sym1, sym2, safeIntersection)
+            JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+          catch case ex: MergeError =>
+            handleConflict
       end mergeSingleDenot
 
       if (this eq that) this

From 288d7efbde600ce2355d31cab97c9076bbd9df6c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 28 May 2020 22:36:39 +0200
Subject: [PATCH 08/20] Disable cps-async

Just to see whether everything else passes. cps-async contains a problem
which was hidden but not solved by the previous disambiguations.
---
 .../test/scala/dotty/communitybuild/CommunityBuildTest.scala    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
index 6c8b7b1d7358..e1dbd4eac735 100644
--- a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
+++ b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
@@ -379,7 +379,7 @@ 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()
+  //@Test def dottyCpsAsync = projects.dottyCpsAsync.run()
   @Test def scalaz = projects.scalaz.run()
   @Test def endpoints = projects.endpoints.run()
 end CommunityBuildTest

From b06055b57730bd2f1106194a253aae8a80c9fc9a Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 29 May 2020 16:58:36 +0200
Subject: [PATCH 09/20] Add minimized test that demonstrates the failure to
 tests/pending

---
 tests/pending/pos/cps-async-failure.scala | 48 +++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 tests/pending/pos/cps-async-failure.scala

diff --git a/tests/pending/pos/cps-async-failure.scala b/tests/pending/pos/cps-async-failure.scala
new file mode 100644
index 000000000000..aef801dad9e9
--- /dev/null
+++ b/tests/pending/pos/cps-async-failure.scala
@@ -0,0 +1,48 @@
+
+import scala.quoted._
+
+trait App[F[_],CT]:
+  this: Base[F,CT] =>
+
+  import qctx.tasty._
+
+  trait AA
+
+  def f(cpsCtx: FC[F]): AA =
+    g(cpsCtx)
+
+  def g(cpsCtx: FC[F]): AA =
+    val paramSym: Symbol = ???
+    println(paramSym.tree)   // println necessary for failure
+    val t: Term = ???
+    t match {                // match necessary for failure
+      case Typed(_, _) => ???  // both cases necessary for failure
+      case Lambda(_, _) => ???
+    }
+    f(cpsCtx)                 // necessary for failure
+    val cpsBody = runRoot()   // necessary for failure
+    g(cpsCtx)                 // failure
+      // 26 |    g(cpsCtx)
+      //    |    ^
+      //    |Ambiguous overload. The overloaded alternatives of method g in trait App with types
+      //    | (cpsCtx: FC[F]): Base.this.AA
+      //    | (cpsCtx: FC[F]): App.this.AA
+      //    |both match arguments ((cpsCtx : FC[F]))
+      //    |
+      //    |Note: this happens because two or more alternatives have the same erasure,
+      //    |      so they cannot be distinguished by overloading resolution
+
+
+class FC[F[_]]()
+
+trait Base[F[_]:Type,CT:Type]  // Both :Type context bounds are necessary for failure
+extends Cps with Root[F, CT] with App[F, CT]:
+  implicit val qctx: QuoteContext
+
+trait Root[F[_], CT]:
+  this: Base[F, CT] =>
+  def runRoot(): CpsTree = ???
+
+trait Cps:
+  sealed abstract class CpsTree
+

From af103a4083a1bf7c070ef495546a718558bf4a44 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 29 May 2020 17:11:07 +0200
Subject: [PATCH 10/20] Performance optimization: Precompute SELECTin criteria

Computing whether we need a SELECTin seems to be expensive and the test is wrong
99.99% of the time. As an optimization, we mark the trees that need a SELECTin
at the time we first detect the problem.
---
 .../src/dotty/tools/dotc/config/Config.scala   | 12 ++++++++----
 .../tools/dotc/core/tasty/TreePickler.scala    | 18 +++++++++++++-----
 .../src/dotty/tools/dotc/typer/Typer.scala     | 13 +++++++++++--
 3 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala
index 6bad889890d4..ddee64fdfcb1 100644
--- a/compiler/src/dotty/tools/dotc/config/Config.scala
+++ b/compiler/src/dotty/tools/dotc/config/Config.scala
@@ -87,10 +87,6 @@ object Config {
    */
   final val alignArgsInAnd = true
 
-  /** If this flag is set, higher-kinded applications are checked for validity
-   */
-  final val checkHKApplications = false
-
   /** If this flag is set, method types are checked for valid parameter references
    */
   final val checkMethodTypes = false
@@ -140,6 +136,14 @@ object Config {
    */
   final val checkAtomsComparisons = false
 
+  /** Normally, a Select node can be unpickled giving just the name and the signature
+   *  of the selected member. However, in some rare cases, this is not enough since there
+   *  are multiple possible members with the same signature. In that case we need to
+   *  pickle the Select with a SELECTin tag. If on, we check that all ambiguous selects do
+   *  get pickled with SELECTin
+   */
+  final val checkAmbiguousSelects = false
+
   /** In `derivedSelect`, rewrite
    *
    *      (S & T)#A  -->  S#A & T#A
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 1d6130e22113..2b0e56290840 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -16,7 +16,8 @@ import StdNames.nme
 import transform.SymUtils._
 import printing.Printer
 import printing.Texts._
-import util.SourceFile
+import util.{SourceFile, Property}
+import config.Config.checkAmbiguousSelects
 import annotation.constructorOnly
 
 object TreePickler {
@@ -30,6 +31,11 @@ object TreePickler {
       if isTermHole then s"{{{ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "}}}"
       else s"[[[ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]]"
   }
+
+  /** Select tree cannot be unambiguously resolved with signature alone,
+   *  needs to be pickled using the SELECTin tag.
+   */
+  val NeedsSelectIn = new Property.StickyKey[Unit]
 }
 
 class TreePickler(pickler: TastyPickler) {
@@ -383,12 +389,14 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              val isAmbiguous =
-                sig != Signature.NotAMethod
-                && qual.tpe.nonPrivateMember(name).match
+              val needsSelectIn = tree.hasAttachment(NeedsSelectIn)
+              if checkAmbiguousSelects then
+                val isAmbiguous = qual.tpe.nonPrivateMember(name) match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
-              if isAmbiguous then
+                assert(needsSelectIn == isAmbiguous,
+                  i"ambiguity misprediction for select node $tree, is ambiguous = $isAmbiguous")
+              if needsSelectIn then
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 8ed14c2fd32b..98975627fdbf 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -40,6 +40,7 @@ import rewrites.Rewrites.patch
 import NavigateAST._
 import transform.SymUtils._
 import transform.TypeUtils._
+import tasty.TreePickler.NeedsSelectIn
 import reporting.trace
 import Nullables.{NotNullInfo, given _}
 import NullOpsDecorator._
@@ -2827,9 +2828,16 @@ class Typer extends Namer
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
       def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
       val alts = altDenots.map(altRef)
+
+      def resolveWith(alt: TermRef) =
+        val resolved = tree.withType(alt)
+        if alts.exists(a => (a ne alt) && a.signature == alt.signature) then
+          resolved.pushAttachment(NeedsSelectIn, ())
+        readaptSimplified(resolved)
+
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
-          readaptSimplified(tree.withType(alt))
+          resolveWith(alt)
         case Nil =>
           // If alternative matches, there are still two ways to recover:
           //  1. If context is an application, try to insert an apply or implicit
@@ -2844,7 +2852,8 @@ class Typer extends Namer
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
               alts.filter(_.info.isParameterless) match {
-                case alt :: Nil => readaptSimplified(tree.withType(alt))
+                case alt :: Nil =>
+                  resolveWith(alt)
                 case _ =>
                   if (altDenots exists (_.info.paramInfoss == ListOfNil))
                     typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)

From dce30798af8a09fd221a8b36208dd7f8ed037b8c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 29 May 2020 18:03:48 +0200
Subject: [PATCH 11/20] Handle SELECTin in TastyPrinter

---
 compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
index 32b2f1d582b8..77442ead9298 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.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()

From 0bc0a2e2ab589c2b3bdf24aae08d648d792bd588 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 29 May 2020 18:08:57 +0200
Subject: [PATCH 12/20] Improve comments

---
 compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala | 7 ++++++-
 tasty/src/dotty/tools/tasty/TastyFormat.scala              | 6 +++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 2b0e56290840..16835c5fc229 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -33,7 +33,9 @@ object TreePickler {
   }
 
   /** Select tree cannot be unambiguously resolved with signature alone,
-   *  needs to be pickled using the SELECTin tag.
+   *  needs to be pickled using the SELECTin tag. This is set by Typer, if
+   *  after overloading resolution it is discovered that other alternatives
+   *  have the same signature as the one that was selected.
    */
   val NeedsSelectIn = new Property.StickyKey[Unit]
 }
@@ -391,6 +393,9 @@ class TreePickler(pickler: TastyPickler) {
               val sig = tree.tpe.signature
               val needsSelectIn = tree.hasAttachment(NeedsSelectIn)
               if checkAmbiguousSelects then
+                // We use needsSelectIn instead of isAmbiguous since isAmbiguous
+                // is more expensive to compute. This matters since either criterion
+                // is false in almost all cases.
                 val isAmbiguous = qual.tpe.nonPrivateMember(name) match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 92aa177bff45..682f067926a0 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -75,7 +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
+                  SELECTin       Length possiblySigned_NameRef qual_Term owner_Type -- qual.name, referring to a symbol declared in owner that has the given signature (see note below)
                   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
@@ -213,6 +213,10 @@ Standard-Section: "ASTs" TopLevelStat*
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term             -- An annotation, given (class) type of constructor, and full application tree
 
+Note: The signature of a SELECTin node is the signature of the selected symbol, not
+      the signature of the reference. The latter undergoes an asSeenFrom but the former
+      does not. TODO: Also use symbol signatures in TERMREFin
+
 Note: Tree tags are grouped into 5 categories that determine what follows, and thus allow to compute the size of the tagged tree in a generic way.
 
   Category 1 (tags 1-49)   :  tag

From 0cf9ee17c29697b663c9045ce10ccfff75773956 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Tue, 2 Jun 2020 09:16:18 +0200
Subject: [PATCH 13/20] Revert "Performance optimization: Precompute SELECTin
 criteria"

This reverts commit af103a4083a1bf7c070ef495546a718558bf4a44.

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
---
 .../src/dotty/tools/dotc/config/Config.scala  | 12 ++++------
 .../tools/dotc/core/tasty/TreePickler.scala   | 23 ++++---------------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 13 ++---------
 3 files changed, 11 insertions(+), 37 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/Config.scala b/compiler/src/dotty/tools/dotc/config/Config.scala
index ddee64fdfcb1..6bad889890d4 100644
--- a/compiler/src/dotty/tools/dotc/config/Config.scala
+++ b/compiler/src/dotty/tools/dotc/config/Config.scala
@@ -87,6 +87,10 @@ object Config {
    */
   final val alignArgsInAnd = true
 
+  /** If this flag is set, higher-kinded applications are checked for validity
+   */
+  final val checkHKApplications = false
+
   /** If this flag is set, method types are checked for valid parameter references
    */
   final val checkMethodTypes = false
@@ -136,14 +140,6 @@ object Config {
    */
   final val checkAtomsComparisons = false
 
-  /** Normally, a Select node can be unpickled giving just the name and the signature
-   *  of the selected member. However, in some rare cases, this is not enough since there
-   *  are multiple possible members with the same signature. In that case we need to
-   *  pickle the Select with a SELECTin tag. If on, we check that all ambiguous selects do
-   *  get pickled with SELECTin
-   */
-  final val checkAmbiguousSelects = false
-
   /** In `derivedSelect`, rewrite
    *
    *      (S & T)#A  -->  S#A & T#A
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 16835c5fc229..1d6130e22113 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -16,8 +16,7 @@ import StdNames.nme
 import transform.SymUtils._
 import printing.Printer
 import printing.Texts._
-import util.{SourceFile, Property}
-import config.Config.checkAmbiguousSelects
+import util.SourceFile
 import annotation.constructorOnly
 
 object TreePickler {
@@ -31,13 +30,6 @@ object TreePickler {
       if isTermHole then s"{{{ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "}}}"
       else s"[[[ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]]"
   }
-
-  /** Select tree cannot be unambiguously resolved with signature alone,
-   *  needs to be pickled using the SELECTin tag. This is set by Typer, if
-   *  after overloading resolution it is discovered that other alternatives
-   *  have the same signature as the one that was selected.
-   */
-  val NeedsSelectIn = new Property.StickyKey[Unit]
 }
 
 class TreePickler(pickler: TastyPickler) {
@@ -391,17 +383,12 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              val needsSelectIn = tree.hasAttachment(NeedsSelectIn)
-              if checkAmbiguousSelects then
-                // We use needsSelectIn instead of isAmbiguous since isAmbiguous
-                // is more expensive to compute. This matters since either criterion
-                // is false in almost all cases.
-                val isAmbiguous = qual.tpe.nonPrivateMember(name) match
+              val isAmbiguous =
+                sig != Signature.NotAMethod
+                && qual.tpe.nonPrivateMember(name).match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
-                assert(needsSelectIn == isAmbiguous,
-                  i"ambiguity misprediction for select node $tree, is ambiguous = $isAmbiguous")
-              if needsSelectIn then
+              if isAmbiguous then
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 98975627fdbf..8ed14c2fd32b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -40,7 +40,6 @@ import rewrites.Rewrites.patch
 import NavigateAST._
 import transform.SymUtils._
 import transform.TypeUtils._
-import tasty.TreePickler.NeedsSelectIn
 import reporting.trace
 import Nullables.{NotNullInfo, given _}
 import NullOpsDecorator._
@@ -2828,16 +2827,9 @@ class Typer extends Namer
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
       def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
       val alts = altDenots.map(altRef)
-
-      def resolveWith(alt: TermRef) =
-        val resolved = tree.withType(alt)
-        if alts.exists(a => (a ne alt) && a.signature == alt.signature) then
-          resolved.pushAttachment(NeedsSelectIn, ())
-        readaptSimplified(resolved)
-
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
-          resolveWith(alt)
+          readaptSimplified(tree.withType(alt))
         case Nil =>
           // If alternative matches, there are still two ways to recover:
           //  1. If context is an application, try to insert an apply or implicit
@@ -2852,8 +2844,7 @@ class Typer extends Namer
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
               alts.filter(_.info.isParameterless) match {
-                case alt :: Nil =>
-                  resolveWith(alt)
+                case alt :: Nil => readaptSimplified(tree.withType(alt))
                 case _ =>
                   if (altDenots exists (_.info.paramInfoss == ListOfNil))
                     typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)

From 162f3fa8f3544bcf7bb77c07413dc75c71d83279 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Tue, 2 Jun 2020 11:59:46 +0200
Subject: [PATCH 14/20] Drop MergeError

---
 .../dotty/tools/dotc/core/Denotations.scala   | 198 ++++--------------
 .../dotty/tools/dotc/core/TypeComparer.scala  |  24 +--
 .../dotty/tools/dotc/core/TypeErrors.scala    |  29 ---
 .../dotty/tools/dotc/typer/RefChecks.scala    |  20 +-
 tests/neg/mixin-class-member-clash.scala      |   7 +
 5 files changed, 51 insertions(+), 227 deletions(-)
 create mode 100644 tests/neg/mixin-class-member-clash.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index f85f7636ef19..b481e2b12a9c 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -387,8 +387,6 @@ object Denotations {
      *  with one of the operand symbols (unspecified which one), and an info which
      *  is the intersection (using `&` or `safe_&` if `safeIntersection` is true)
      *  of the infos of the operand denotations.
-     *
-     *  If SingleDenotations with different signatures are joined, return NoDenotation.
      */
     def & (that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
       /** Try to merge denot1 and denot2 without adding a new signature. */
@@ -418,10 +416,10 @@ object Denotations {
 
         /** Does `sym1` come before `sym2` in the linearization of `pre`? */
         def precedes(sym1: Symbol, sym2: Symbol) = {
-          def precedesIn(bcs: List[ClassSymbol]): Boolean = bcs match {
+          def precedesIn(bcs: List[ClassSymbol]): Boolean = bcs match
             case bc :: bcs1 => (sym1 eq bc) || !(sym2 eq bc) && precedesIn(bcs1)
             case Nil => false
-          }
+
           (sym1 ne sym2) &&
             (sym1.derivesFrom(sym2) ||
               !sym2.derivesFrom(sym1) && precedesIn(pre.baseClasses))
@@ -503,12 +501,13 @@ object Denotations {
           else if (sym1Accessible && sym2.exists && !sym2Accessible) denot1
           else if (sym2Accessible && sym1.exists && !sym1Accessible) denot2
           else if isDoubleDef(sym1, sym2) then handleConflict
-          else try
+          else
             val sym = if preferSym(sym2, sym1) then sym2 else sym1
-            val jointInfo = infoMeet(info1, info2, sym1, sym2, safeIntersection)
-            JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
-          catch case ex: MergeError =>
-            handleConflict
+            val jointInfo = infoMeet(info1, info2, safeIntersection)
+            if jointInfo.exists then
+              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+            else
+              handleConflict
       end mergeSingleDenot
 
       if (this eq that) this
@@ -523,63 +522,6 @@ object Denotations {
       }
     }
 
-    /** Form a choice between this denotation and that one.
-     *  @param pre  The prefix type of the members of the denotation, used
-     *              to determine an accessible symbol if it exists.
-     */
-    def | (that: Denotation, pre: Type)(implicit ctx: Context): Denotation = {
-
-      def unionDenot(denot1: SingleDenotation, denot2: SingleDenotation): Denotation =
-        if (denot1.matches(denot2)) {
-          val sym1 = denot1.symbol
-          val sym2 = denot2.symbol
-          val info1 = denot1.info
-          val info2 = denot2.info
-          val sameSym = sym1 eq sym2
-          if (sameSym && (info1.widenExpr frozen_<:< info2.widenExpr)) denot2
-          else if (sameSym && (info2.widenExpr frozen_<:< info1.widenExpr)) denot1
-          else {
-            val jointSym =
-              if (sameSym) sym1
-              else {
-                val owner2 = if (sym2 ne NoSymbol) sym2.owner else NoSymbol
-                /** Determine a symbol which is overridden by both sym1 and sym2.
-                 *  Preference is given to accessible symbols.
-                 */
-                def lubSym(overrides: Iterator[Symbol], previous: Symbol): Symbol =
-                  if (!overrides.hasNext) previous
-                  else {
-                    val candidate = overrides.next()
-                    if (owner2 derivesFrom candidate.owner)
-                      if (candidate isAccessibleFrom pre) candidate
-                      else lubSym(overrides, previous orElse candidate)
-                    else
-                      lubSym(overrides, previous)
-                  }
-                lubSym(sym1.allOverriddenSymbols, NoSymbol)
-              }
-            new JointRefDenotation(
-                jointSym, infoJoin(info1, info2, sym1, sym2), denot1.validFor & denot2.validFor, pre)
-          }
-        }
-        else NoDenotation
-
-      if (this eq that) this
-      else if (!this.exists) this
-      else if (!that.exists) that
-      else this match {
-        case denot1 @ MultiDenotation(denot11, denot12) =>
-          denot1.derivedUnionDenotation(denot11 | (that, pre), denot12 | (that, pre))
-        case denot1: SingleDenotation =>
-          that match {
-            case denot2 @ MultiDenotation(denot21, denot22) =>
-              denot2.derivedUnionDenotation(this | (denot21, pre), this | (denot22, pre))
-            case denot2: SingleDenotation =>
-              unionDenot(denot1, denot2)
-          }
-      }
-    }
-
     final def asSingleDenotation: SingleDenotation = asInstanceOf[SingleDenotation]
     final def asSymDenotation: SymDenotation = asInstanceOf[SymDenotation]
 
@@ -593,10 +535,6 @@ object Denotations {
 
   // ------ Info meets and joins ---------------------------------------------
 
-  /** Handle merge conflict by throwing a `MergeError` exception */
-  private def mergeConflict(sym1: Symbol, sym2: Symbol, tp1: Type, tp2: Type)(implicit ctx: Context): Type =
-    throw new MergeError(sym1, sym2, tp1, tp2, NoPrefix)
-
   /** Merge parameter names of lambda types. If names in corresponding positions match, keep them,
     *  otherwise generate new synthetic names.
     */
@@ -604,25 +542,25 @@ object Denotations {
     (for ((name1, name2, idx) <- tp1.paramNames.lazyZip(tp2.paramNames).lazyZip(tp1.paramNames.indices))
       yield if (name1 == name2) name1 else tp1.companion.syntheticParamName(idx)).toList
 
-  /** Normally, `tp1 & tp2`.
+  /** Normally, `tp1 & tp2`
     *  Special cases for matching methods and classes, with
-    *  the possibility of raising a merge error.
+    *  the possibility of returning NoType.
     *  Special handling of ExprTypes, where mixed intersections widen the ExprType away.
     */
-  def infoMeet(tp1: Type, tp2: Type, sym1: Symbol, sym2: Symbol, safeIntersection: Boolean)(implicit ctx: Context): Type =
+  def infoMeet(tp1: Type, tp2: Type, safeIntersection: Boolean)(implicit ctx: Context): Type =
     if (tp1 eq tp2) tp1
     else tp1 match {
       case tp1: TypeBounds =>
         tp2 match {
           case tp2: TypeBounds => if (safeIntersection) tp1 safe_& tp2 else tp1 & tp2
           case tp2: ClassInfo => tp2
-          case _ => mergeConflict(sym1, sym2, tp1, tp2)
+          case _ => NoType
         }
       case tp1: ClassInfo =>
         tp2 match {
           case tp2: ClassInfo if tp1.cls eq tp2.cls => tp1.derivedClassInfo(tp1.prefix & tp2.prefix)
           case tp2: TypeBounds => tp1
-          case _ => mergeConflict(sym1, sym2, tp1, tp2)
+          case _ => NoType
         }
 
       // Two remedial strategies:
@@ -640,40 +578,39 @@ object Denotations {
       //    and result types.
       case tp1: MethodType =>
         tp2 match {
-          case tp2: PolyType =>
-            tp1
           case tp2: MethodType
           if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
-            tp1.derivedLambdaType(
-              mergeParamNames(tp1, tp2),
-              tp1.paramInfos,
-              infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1), sym1, sym2, safeIntersection))
+            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
+            if resType.exists then
+              tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
+            else
+              NoType
           case _ =>
-            mergeConflict(sym1, sym2, tp1, tp2)
+            NoType
         }
       case tp1: PolyType =>
         tp2 match {
-          case tp2: MethodType =>
-            tp2
           case tp2: PolyType if ctx.typeComparer.matchingPolyParams(tp1, tp2) =>
-            tp1.derivedLambdaType(
-              mergeParamNames(tp1, tp2),
-              tp1.paramInfos.zipWithConserve(tp2.paramInfos) { (p1, p2) =>
-                infoMeet(p1, p2.subst(tp2, tp1), sym1, sym2, safeIntersection).bounds
-              },
-              infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1), sym1, sym2, safeIntersection))
+            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
+            if resType.exists then
+              tp1.derivedLambdaType(
+                mergeParamNames(tp1, tp2),
+                tp1.paramInfos.zipWithConserve(tp2.paramInfos)( _ & _ ),
+                resType)
+            else
+              NoType
           case _ =>
-            mergeConflict(sym1, sym2, tp1, tp2)
+            NoType
         }
       case ExprType(rtp1) =>
         tp2 match {
           case ExprType(rtp2) => ExprType(rtp1 & rtp2)
-          case _ => infoMeet(rtp1, tp2, sym1, sym2, safeIntersection)
+          case _ => infoMeet(rtp1, tp2, safeIntersection)
         }
       case _ =>
         tp2 match
           case _: MethodType | _: PolyType =>
-            mergeConflict(sym1, sym2, tp1, tp2)
+            NoType
           case _ =>
             try tp1 & tp2.widenExpr
             catch
@@ -682,57 +619,6 @@ object Denotations {
                 throw ex
     }
 
-  /** Normally, `tp1 | tp2`.
-    *  Special cases for matching methods and classes, with
-    *  the possibility of raising a merge error.
-    *  Special handling of ExprTypes, where mixed unions widen the ExprType away.
-    */
-  def infoJoin(tp1: Type, tp2: Type, sym1: Symbol, sym2: Symbol)(implicit ctx: Context): Type = tp1 match {
-    case tp1: TypeBounds =>
-      tp2 match {
-        case tp2: TypeBounds => tp1 | tp2
-        case tp2: ClassInfo if tp1 contains tp2 => tp1
-        case _ => mergeConflict(sym1, sym2, tp1, tp2)
-      }
-    case tp1: ClassInfo =>
-      tp2 match {
-        case tp2: ClassInfo if tp1.cls eq tp2.cls => tp1.derivedClassInfo(tp1.prefix | tp2.prefix)
-        case tp2: TypeBounds if tp2 contains tp1 => tp2
-        case _ => mergeConflict(sym1, sym2, tp1, tp2)
-      }
-    case tp1: MethodType =>
-      tp2 match {
-        case tp2: MethodType
-        if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
-          tp1.derivedLambdaType(
-            mergeParamNames(tp1, tp2),
-            tp1.paramInfos,
-            infoJoin(tp1.resultType, tp2.resultType.subst(tp2, tp1), sym1, sym2))
-        case _ =>
-          mergeConflict(sym1, sym2, tp1, tp2)
-      }
-    case tp1: PolyType =>
-      tp2 match {
-        case tp2: PolyType
-        if ctx.typeComparer.matchingPolyParams(tp1, tp2) =>
-          tp1.derivedLambdaType(
-            mergeParamNames(tp1, tp2),
-            tp1.paramInfos.zipWithConserve(tp2.paramInfos) { (p1, p2) =>
-              infoJoin(p1, p2.subst(tp2, tp1), sym1, sym2).bounds
-            },
-            infoJoin(tp1.resultType, tp2.resultType.subst(tp2, tp1), sym1, sym2))
-        case _ =>
-          mergeConflict(sym1, sym2, tp1, tp2)
-      }
-    case ExprType(rtp1) =>
-      tp2 match {
-        case ExprType(rtp2) => ExprType(rtp1 | rtp2)
-        case _ => rtp1 | tp2
-      }
-    case _ =>
-      tp1 | tp2.widenExpr
-  }
-
   /** A non-overloaded denotation */
   abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
     protected def newLikeThis(symbol: Symbol, info: Type, pre: Type): SingleDenotation
@@ -1248,20 +1134,6 @@ object Denotations {
     (sym1 `ne` sym2) && (sym1.effectiveOwner `eq` sym2.effectiveOwner) &&
     !sym1.is(Bridge) && !sym2.is(Bridge))
 
-  def doubleDefError(denot1: Denotation, denot2: Denotation, pre: Type = NoPrefix)(implicit ctx: Context): Nothing = {
-    val sym1 = denot1.symbol
-    val sym2 = denot2.symbol
-    if (denot1.isTerm)
-      throw new MergeError(sym1, sym2, sym1.info, sym2.info, pre) {
-        override def addendum(implicit ctx: Context) =
-          i"""
-             |they are both defined in ${this.sym1.effectiveOwner} but have matching signatures
-             |  ${denot1.info} and
-             |  ${denot2.info}${super.addendum}"""
-      }
-    else throw new MergeError(sym1, sym2, denot1.info, denot2.info, pre)
-  }
-
   // --- Overloaded denotations and predenotations -------------------------------------------------
 
   trait MultiPreDenotation extends PreDenotation {
@@ -1318,10 +1190,12 @@ object Denotations {
     def suchThat(p: Symbol => Boolean)(implicit ctx: Context): SingleDenotation = {
       val sd1 = denot1.suchThat(p)
       val sd2 = denot2.suchThat(p)
-      if (sd1.exists)
-        if (sd2.exists)
-          if (isDoubleDef(denot1.symbol, denot2.symbol)) doubleDefError(denot1, denot2)
-          else throw new TypeError(i"failure to disambiguate overloaded reference at $this")
+      if sd1.exists then
+        if sd2.exists then
+          throw TypeError(
+            em"""Failure to disambiguate oberloaded reference with
+                |  ${denot1.symbol.showLocated}: ${denot1.info}  and
+                |  ${denot2.symbol.showLocated}: ${denot2.info}""")
         else sd1
       else sd2
     }
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9d21925c6a77..380d0be7f613 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2049,16 +2049,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)
@@ -2072,10 +2062,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.
    */
@@ -2141,13 +2127,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
       }
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index b335cf0695a5..24db641b7fca 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.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
-       """
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 7e08fd2522ac..41f720a9ae67 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.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.
diff --git a/tests/neg/mixin-class-member-clash.scala b/tests/neg/mixin-class-member-clash.scala
new file mode 100644
index 000000000000..35c02a85c904
--- /dev/null
+++ b/tests/neg/mixin-class-member-clash.scala
@@ -0,0 +1,7 @@
+trait T {
+  class C
+}
+trait U {
+  class C
+}
+class C extends T, U // error: error overriding class C in trait T

From e82756a60fbaa52bcca99876888add48ea4e2b3c Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Tue, 2 Jun 2020 13:59:15 +0200
Subject: [PATCH 15/20] Simplify implementation of & on denotations

---
 .../dotty/tools/dotc/core/Denotations.scala   | 213 +++++++-----------
 .../tools/dotc/core/SymDenotations.scala      |   6 +-
 .../allow-double-bindings/i1240.scala         |   2 +-
 tests/neg/i4470a.scala                        |   2 +-
 tests/neg/i4470b.scala                        |   2 +-
 tests/neg/i4470c.scala                        |   2 +-
 6 files changed, 85 insertions(+), 142 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index b481e2b12a9c..0e6a4de0d26b 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -385,7 +385,7 @@ object Denotations {
      *
      *  If there is no preferred accessible denotation, return a JointRefDenotation
      *  with one of the operand symbols (unspecified which one), and an info which
-     *  is the intersection (using `&` or `safe_&` if `safeIntersection` is true)
+     *  is the intersection using `&` or `safe_&` if `safeIntersection` is true)
      *  of the infos of the operand denotations.
      */
     def & (that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
@@ -412,18 +412,21 @@ object Denotations {
         val sym1 = denot1.symbol
         val sym2 = denot2.symbol
 
-        val sym2Accessible = sym2.isAccessibleFrom(pre)
-
         /** Does `sym1` come before `sym2` in the linearization of `pre`? */
-        def precedes(sym1: Symbol, sym2: Symbol) = {
-          def precedesIn(bcs: List[ClassSymbol]): Boolean = bcs match
-            case bc :: bcs1 => (sym1 eq bc) || !(sym2 eq bc) && precedesIn(bcs1)
-            case Nil => false
-
-          (sym1 ne sym2) &&
-            (sym1.derivesFrom(sym2) ||
-              !sym2.derivesFrom(sym1) && precedesIn(pre.baseClasses))
-        }
+        def linearScore(owner1: Symbol, owner2: Symbol): Int =
+
+          def searchBaseClasses(bcs: List[ClassSymbol]): Int = bcs match
+            case bc :: bcs1 =>
+              if bc eq owner1 then 1
+              else if bc eq owner2 then -1
+              else searchBaseClasses(bcs1)
+            case Nil => 0
+
+          if owner1 eq owner2 then 0
+          else if owner1.derivesFrom(owner2) then 1
+          else if owner2.derivesFrom(owner1) then -1
+          else searchBaseClasses(pre.baseClasses)
+        end linearScore
 
         /** Similar to SymDenotation#accessBoundary, but without the special cases. */
         def accessBoundary(sym: Symbol) =
@@ -432,82 +435,49 @@ object Denotations {
             if (sym.is(Protected)) sym.owner.enclosingPackageClass
             else defn.RootClass)
 
-        /** Establish a partial order "preference" order between symbols.
-         *  Give preference to `sym1` over `sym2` if one of the following
-         *  conditions holds, in decreasing order of weight:
-         *   1. sym2 doesn't exist
-         *   2. sym1 is concrete and sym2 is abstract
-         *   3. The owner of sym1 comes before the owner of sym2 in the linearization
-         *      of the type of the prefix `pre`.
-         *   4. The access boundary of sym2 is properly contained in the access
-         *      boundary of sym1. For protected access, we count the enclosing
-         *      package as access boundary.
-         *   5. sym1 is a method but sym2 is not.
-         *  The aim of these criteria is to give some disambiguation on access which
-         *   - does not depend on textual order or other arbitrary choices
-         *   - minimizes raising of doubleDef errors
-         */
-        def preferSym(sym1: Symbol, sym2: Symbol) =
-          sym1.eq(sym2)
-          || sym1.exists
-             && (!sym2.exists
-                || sym1.isAsConcrete(sym2)
-                   && (!sym2.isAsConcrete(sym1)
-                      || precedes(sym1.owner, sym2.owner)
-                      || accessBoundary(sym2).isProperlyContainedIn(accessBoundary(sym1))
-                      || sym2.is(Bridge) && !sym1.is(Bridge)
-                      || sym1.is(Method) && !sym2.is(Method))
-                || sym1.info.isErroneous)
-
-        /** Sym preference provided types also override */
-        def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
-          preferSym(sym1, sym2) &&
-          info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely, checkClassInfo = false)
-
-        /** Handle conflict where we have either definitions coming from the same class
-         *  that have matching signatures as seen from the current prefix, or we have
-         *  definitions from different classes that have the same signature but
-         *  conflicting infos. In these cases, do a last minute disambiguation
-         *  by picking one alternative according to the ranking
-         *
-         *    1. Non-bridge methods
-         *    2. non-methods
-         *    3. bridges
-         *    4. NoSymbol
-         *
-         *  If that fails, return a MultiDenotation with both alternatives
-         *  and rely on overloading resolution to pick one of them.
-         */
-        def handleConflict: Denotation =
-
-          def preferMethod(sym1: Symbol, sym2: Symbol): Boolean =
-            sym1.exists &&
-              (!sym2.exists
-              || sym2.is(Bridge) && !sym1.is(Bridge)
-              || sym1.is(Method) && !sym2.is(Method)
-              || sym1.info.isErroneous)
-
-          if preferMethod(sym1, sym2) then denot1
-          else if preferMethod(sym2, sym1) then denot2
-          else
-            overload.println(i"overloaded with same signature: ${sym1.showLocated}: $info1 / ${sym2.showLocated}: $info2")
-            MultiDenotation(denot1, denot2)
-        end handleConflict
-
-        if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
+        def isHidden(sym: Symbol) = sym.exists && !sym.isAccessibleFrom(pre)
+        val hidden1 = isHidden(sym1)
+        val hidden2 = isHidden(sym2)
+        if hidden1 && !hidden2 then denot2
+        else if hidden2 && !hidden1 then denot1
         else
-          val sym1Accessible = sym1.isAccessibleFrom(pre)
-          if (sym1Accessible && prefer(sym1, sym2, info1, info2)) denot1
-          else if (sym1Accessible && sym2.exists && !sym2Accessible) denot1
-          else if (sym2Accessible && sym1.exists && !sym1Accessible) denot2
-          else if isDoubleDef(sym1, sym2) then handleConflict
+          val symScore: Int =
+            if !sym1.exists then -2
+            else if !sym2.exists then 2
+            else if !sym1.isAsConcrete(sym2) then -1
+            else if !sym2.isAsConcrete(sym1) then 1
+            else
+              val linScore = linearScore(sym1.owner, sym2.owner)
+              if linScore != 0 then linScore
+              else
+                val boundary1 = accessBoundary(sym1)
+                val boundary2 = accessBoundary(sym2)
+                if boundary1.isProperlyContainedIn(boundary2) then -1
+                else if boundary2.isProperlyContainedIn(boundary1) then 1
+                else if sym1.is(Bridge) && !sym2.is(Bridge) then -2
+                else if sym2.is(Bridge) && !sym1.is(Bridge) then 2
+                else if sym2.is(Method) && !sym1.is(Method) then -2
+                else if sym1.is(Method) && !sym2.is(Method) then 2
+                else 0
+
+          val matchLoosely = sym1.matchNullaryLoosely || sym2.matchNullaryLoosely
+
+          if info2.overrides(info1, matchLoosely, checkClassInfo = false)
+             && symScore <= 0
+          then denot2
+          else if info1.overrides(info2, matchLoosely, checkClassInfo = false)
+                  && symScore >= 0
+          then denot1
           else
-            val sym = if preferSym(sym2, sym1) then sym2 else sym1
             val jointInfo = infoMeet(info1, info2, safeIntersection)
             if jointInfo.exists then
+              val sym = if symScore > 0 then sym1 else sym2
               JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+            else if symScore == 2 then denot1
+            else if symScore == -2 then denot2
             else
-              handleConflict
+              overload.println(i"overloaded with same signature: ${sym1.showLocated}: $info1 / ${sym2.showLocated}: $info2, info = ${info1.getClass}, ${info2.getClass}, $jointInfo")
+              MultiDenotation(denot1, denot2)
       end mergeSingleDenot
 
       if (this eq that) this
@@ -533,7 +503,7 @@ object Denotations {
     final def containsSym(sym: Symbol): Boolean = hasUniqueSym && (symbol eq sym)
   }
 
-  // ------ Info meets and joins ---------------------------------------------
+  // ------ Info meets ----------------------------------------------------
 
   /** Merge parameter names of lambda types. If names in corresponding positions match, keep them,
     *  otherwise generate new synthetic names.
@@ -542,82 +512,55 @@ object Denotations {
     (for ((name1, name2, idx) <- tp1.paramNames.lazyZip(tp2.paramNames).lazyZip(tp1.paramNames.indices))
       yield if (name1 == name2) name1 else tp1.companion.syntheticParamName(idx)).toList
 
-  /** Normally, `tp1 & tp2`
-    *  Special cases for matching methods and classes, with
-    *  the possibility of returning NoType.
-    *  Special handling of ExprTypes, where mixed intersections widen the ExprType away.
-    */
+  /** Normally, `tp1 & tp2`, with extra care taken to return `tp1` or `tp2` directly if that's
+   *  a valid answer. Special cases for matching methods and classes, with
+   *  the possibility of returning NoType. Special handling of ExprTypes, where mixed
+   *  intersections widen the ExprType away.
+   */
   def infoMeet(tp1: Type, tp2: Type, safeIntersection: Boolean)(implicit ctx: Context): Type =
-    if (tp1 eq tp2) tp1
-    else tp1 match {
+    if tp1 eq tp2 then tp1
+    else tp1 match
       case tp1: TypeBounds =>
-        tp2 match {
-          case tp2: TypeBounds => if (safeIntersection) tp1 safe_& tp2 else tp1 & tp2
+        tp2 match
+          case tp2: TypeBounds => if safeIntersection then tp1 safe_& tp2 else tp1 & tp2
           case tp2: ClassInfo => tp2
           case _ => NoType
-        }
       case tp1: ClassInfo =>
-        tp2 match {
+        tp2 match
           case tp2: ClassInfo if tp1.cls eq tp2.cls => tp1.derivedClassInfo(tp1.prefix & tp2.prefix)
           case tp2: TypeBounds => tp1
           case _ => NoType
-        }
-
-      // Two remedial strategies:
-      //
-      //  1. Prefer method types over poly types. This is necessary to handle
-      //     overloaded definitions like the following
-      //
-      //        def ++ [B >: A](xs: C[B]): D[B]
-      //        def ++ (xs: C[A]): D[A]
-      //
-      //     (Code like this is found in the collection strawman)
-      //
-      // 2. In the case of two method types or two polytypes with matching
-      //    parameters and implicit status, merge corresponding parameter
-      //    and result types.
       case tp1: MethodType =>
-        tp2 match {
+        tp2 match
           case tp2: MethodType
-          if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
+          if ctx.typeComparer.matchingMethodParams(tp1, tp2)
+             && (tp1.isImplicitMethod || tp1.isContextualMethod) == (tp2.isImplicitMethod || tp2.isContextualMethod)
+             && tp1.isErasedMethod == tp2.isErasedMethod =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
               tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
-            else
-              NoType
-          case _ =>
-            NoType
-        }
+            else NoType
+          case _ => NoType
       case tp1: PolyType =>
-        tp2 match {
-          case tp2: PolyType if ctx.typeComparer.matchingPolyParams(tp1, tp2) =>
+        tp2 match
+          case tp2: PolyType if sameLength(tp1.paramNames, tp2.paramNames) =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
               tp1.derivedLambdaType(
                 mergeParamNames(tp1, tp2),
                 tp1.paramInfos.zipWithConserve(tp2.paramInfos)( _ & _ ),
                 resType)
-            else
-              NoType
-          case _ =>
-            NoType
-        }
+            else NoType
+          case _ => NoType
       case ExprType(rtp1) =>
-        tp2 match {
+        tp2 match
           case ExprType(rtp2) => ExprType(rtp1 & rtp2)
           case _ => infoMeet(rtp1, tp2, safeIntersection)
-        }
       case _ =>
         tp2 match
-          case _: MethodType | _: PolyType =>
-            NoType
-          case _ =>
-            try tp1 & tp2.widenExpr
-            catch
-              case ex: Throwable =>
-                println(i"error for meet: $tp1 &&& $tp2, ${tp1.getClass}, ${tp2.getClass}")
-                throw ex
-    }
+          case _: MethodType | _: PolyType => NoType
+          case _ => tp1 & tp2.widenExpr
+  end infoMeet
 
   /** A non-overloaded denotation */
   abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
@@ -1193,7 +1136,7 @@ object Denotations {
       if sd1.exists then
         if sd2.exists then
           throw TypeError(
-            em"""Failure to disambiguate oberloaded reference with
+            em"""Failure to disambiguate overloaded reference with
                 |  ${denot1.symbol.showLocated}: ${denot1.info}  and
                 |  ${denot2.symbol.showLocated}: ${denot2.info}""")
         else sd1
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index b3f952e292a2..e32ed23bc911 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.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)
 
@@ -2100,7 +2100,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 =
diff --git a/tests/neg-custom-args/allow-double-bindings/i1240.scala b/tests/neg-custom-args/allow-double-bindings/i1240.scala
index 3f4d1e210592..5306f2c6ad20 100644
--- a/tests/neg-custom-args/allow-double-bindings/i1240.scala
+++ b/tests/neg-custom-args/allow-double-bindings/i1240.scala
@@ -8,7 +8,7 @@ class C[T] {
 
 object C {
   def main(args: Array[String]) =
-        new C[D]().foo(new D()) // error: ambiguous
+        new C[D]().foo(new D())
 }
 
 class C1[T] {
diff --git a/tests/neg/i4470a.scala b/tests/neg/i4470a.scala
index 001b286a1d74..1733a3e9b6fe 100644
--- a/tests/neg/i4470a.scala
+++ b/tests/neg/i4470a.scala
@@ -1,7 +1,7 @@
 object RepeatedEnum {
 
   enum Maybe { // error
-    case Foo   // error
+    case Foo
   }
 
   enum Maybe { // error
diff --git a/tests/neg/i4470b.scala b/tests/neg/i4470b.scala
index 7305f1018cbe..68fad4cd2a7e 100644
--- a/tests/neg/i4470b.scala
+++ b/tests/neg/i4470b.scala
@@ -1,6 +1,6 @@
 object RepeatedExtendEnum {
 
-  enum Maybe[T] derives Eql { // error // error
+  enum Maybe[T] derives Eql { // error
     case Foo extends Maybe[Int]
   }
 
diff --git a/tests/neg/i4470c.scala b/tests/neg/i4470c.scala
index a77d185818ee..82e4a1ffa4db 100644
--- a/tests/neg/i4470c.scala
+++ b/tests/neg/i4470c.scala
@@ -1,6 +1,6 @@
 object DuplicatedEnum {
   enum Maybe[+T] { // error
-    case Some(x: T) // error
+    case Some(x: T)
   }
 
   enum Maybe[+T] { // error

From d8c980f356bec02c1d453b66ebbf872971aa1cfb Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Tue, 2 Jun 2020 19:59:13 +0200
Subject: [PATCH 16/20] Rename `&` to `meet` and update doc comments

---
 .../dotty/tools/dotc/core/Denotations.scala   | 51 +++++++++++--------
 .../src/dotty/tools/dotc/core/Types.scala     |  4 +-
 2 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 0e6a4de0d26b..a066abac335f 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -366,29 +366,32 @@ object Denotations {
      *
      *  NoDenotations are dropped. MultiDenotations are handled by merging
      *  parts with same signatures. SingleDenotations with equal signatures
-     *  are joined as follows:
+     *  are joined by following this sequence of steps:
      *
-     *  In a first step, consider only those denotations which have symbols
-     *  that are accessible from prefix `pre`.
+     *  1. If exactly one the denotations has an inaccessible symbol, pick the other one.
+     *  2. Otherwise, if one of the infos overrides the other one, and the associated
+     *     symbol does not score strictly lower than the other one,
+     *     pick the associated denotation.
+     *  3. Otherwise, if the two infos can be combined with `infoMeet`, pick that as
+     *     result info, and pick the symbol that scores higher as result symbol,
+     *     or pick `sym2` as a tie breaker. The picked info and symbol are combined
+     *     in a JointDenotation.
+     *  4. Otherwise, if one of the two symbols scores strongly higher than the
+     *     other one, pick the associated denotation.
+     *  5. Otherwise return a multi-denotation consisting of both denotations.
      *
-     *  If there are several such denotations, try to pick one by applying the following
-     *  three precedence rules in decreasing order of priority:
+     *  Symbol scoring is determined according to the following ranking
+     *  where earlier criteria trump later ones. Cases marked with (*)
+     *  give a strong score advantage, the others a weak one.
      *
-     *  1. Prefer denotations with more specific infos.
-     *  2. If infos are equally specific, prefer denotations with concrete symbols over denotations
-     *     with abstract symbols.
-     *  3. If infos are equally specific and symbols are equally concrete,
-     *     prefer denotations with symbols defined in subclasses
-     *     over denotations with symbols defined in proper superclasses.
-     *
-     *  If there is exactly one (preferred) accessible denotation, return it.
-     *
-     *  If there is no preferred accessible denotation, return a JointRefDenotation
-     *  with one of the operand symbols (unspecified which one), and an info which
-     *  is the intersection using `&` or `safe_&` if `safeIntersection` is true)
-     *  of the infos of the operand denotations.
+     *  1. The symbol exists, and the other one does not. (*)
+     *  2. The symbol is concrete, and the other one is deferred
+     *  3. The symbol appears before the other in the linearization of `pre`
+     *  4. The symbol's visibility is strictly greater than the other one's.
+     *  5. The symbol is not a bridge, but the other one is. (*)
+     *  6. The symbol is a method, but the other one is not. (*)
      */
-    def & (that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
+    def meet(that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
       /** Try to merge denot1 and denot2 without adding a new signature. */
       def mergeDenot(denot1: Denotation, denot2: SingleDenotation): Denotation = denot1 match {
         case denot1 @ MultiDenotation(denot11, denot12) =>
@@ -412,7 +415,7 @@ object Denotations {
         val sym1 = denot1.symbol
         val sym2 = denot2.symbol
 
-        /** Does `sym1` come before `sym2` in the linearization of `pre`? */
+        /** Does `owner1` come before `owner2` in the linearization of `pre`? */
         def linearScore(owner1: Symbol, owner2: Symbol): Int =
 
           def searchBaseClasses(bcs: List[ClassSymbol]): Int = bcs match
@@ -441,6 +444,10 @@ object Denotations {
         if hidden1 && !hidden2 then denot2
         else if hidden2 && !hidden1 then denot1
         else
+          // The score that determines which symbol to pick for the result denotation.
+          // A value > 0 means pick `sym1`, < 0 means pick `sym2`.
+          // A value of +/- 2 means pick one of the denotations as a tie-breaker
+          // if a common info does not exist.
           val symScore: Int =
             if !sym1.exists then -2
             else if !sym2.exists then 2
@@ -488,7 +495,7 @@ object Denotations {
           val r = mergeDenot(this, that)
           if (r.exists) r else MultiDenotation(this, that)
         case that @ MultiDenotation(denot1, denot2) =>
-          this & (denot1, pre) & (denot2, pre)
+          this.meet(denot1, pre).meet(denot2, pre)
       }
     }
 
@@ -1106,7 +1113,7 @@ object Denotations {
   final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
     def exists: Boolean = true
     def toDenot(pre: Type)(implicit ctx: Context): Denotation =
-      denot1.toDenot(pre).&(denot2.toDenot(pre), pre)
+      denot1.toDenot(pre).meet(denot2.toDenot(pre), pre)
     def containsSym(sym: Symbol): Boolean =
       (denot1 containsSym sym) || (denot2 containsSym sym)
     type AsSeenFromResult = PreDenotation
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 9aa181bd2b02..031658e62409 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.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) =>

From 64e079055bf7e762b920bc34b83498935324de0d Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Tue, 2 Jun 2020 21:32:50 +0200
Subject: [PATCH 17/20] Experiment with different symbol preference scheme

---
 .../dotty/tools/dotc/core/Denotations.scala    | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index a066abac335f..d2d4290b582e 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -385,11 +385,11 @@ object Denotations {
      *  give a strong score advantage, the others a weak one.
      *
      *  1. The symbol exists, and the other one does not. (*)
-     *  2. The symbol is concrete, and the other one is deferred
-     *  3. The symbol appears before the other in the linearization of `pre`
-     *  4. The symbol's visibility is strictly greater than the other one's.
-     *  5. The symbol is not a bridge, but the other one is. (*)
-     *  6. The symbol is a method, but the other one is not. (*)
+     *  2. The symbol is not a bridge, but the other one is. (*)
+     *  3. The symbol is concrete, and the other one is deferred
+     *  4. The symbol appears before the other in the linearization of `pre`
+     *  5. The symbol's visibility is strictly greater than the other one's.
+     *  6. The symbol is a method, but the other one is not.
      */
     def meet(that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
       /** Try to merge denot1 and denot2 without adding a new signature. */
@@ -451,6 +451,8 @@ object Denotations {
           val symScore: Int =
             if !sym1.exists then -2
             else if !sym2.exists then 2
+            else if sym1.is(Bridge) && !sym2.is(Bridge) then -2
+            else if sym2.is(Bridge) && !sym1.is(Bridge) then 2
             else if !sym1.isAsConcrete(sym2) then -1
             else if !sym2.isAsConcrete(sym1) then 1
             else
@@ -461,10 +463,8 @@ object Denotations {
                 val boundary2 = accessBoundary(sym2)
                 if boundary1.isProperlyContainedIn(boundary2) then -1
                 else if boundary2.isProperlyContainedIn(boundary1) then 1
-                else if sym1.is(Bridge) && !sym2.is(Bridge) then -2
-                else if sym2.is(Bridge) && !sym1.is(Bridge) then 2
-                else if sym2.is(Method) && !sym1.is(Method) then -2
-                else if sym1.is(Method) && !sym2.is(Method) then 2
+                else if sym2.is(Method) && !sym1.is(Method) then -1
+                else if sym1.is(Method) && !sym2.is(Method) then 1
                 else 0
 
           val matchLoosely = sym1.matchNullaryLoosely || sym2.matchNullaryLoosely

From 51ebf7065a4a9bb7e9c49cec5f6fd4ff3568b2c7 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 4 Jun 2020 10:15:48 +0200
Subject: [PATCH 18/20] Use first symbol as tie breaker

---
 .../src/dotty/tools/dotc/core/Denotations.scala    | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index d2d4290b582e..e98cbb87cf1b 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -374,7 +374,7 @@ object Denotations {
      *     pick the associated denotation.
      *  3. Otherwise, if the two infos can be combined with `infoMeet`, pick that as
      *     result info, and pick the symbol that scores higher as result symbol,
-     *     or pick `sym2` as a tie breaker. The picked info and symbol are combined
+     *     or pick `sym1` as a tie breaker. The picked info and symbol are combined
      *     in a JointDenotation.
      *  4. Otherwise, if one of the two symbols scores strongly higher than the
      *     other one, pick the associated denotation.
@@ -469,16 +469,14 @@ object Denotations {
 
           val matchLoosely = sym1.matchNullaryLoosely || sym2.matchNullaryLoosely
 
-          if info2.overrides(info1, matchLoosely, checkClassInfo = false)
-             && symScore <= 0
-          then denot2
-          else if info1.overrides(info2, matchLoosely, checkClassInfo = false)
-                  && symScore >= 0
-          then denot1
+          if symScore <= 0 && info2.overrides(info1, matchLoosely, checkClassInfo = false) then
+            denot2
+          else if symScore >= 0 && info1.overrides(info2, matchLoosely, checkClassInfo = false) then
+            denot1
           else
             val jointInfo = infoMeet(info1, info2, safeIntersection)
             if jointInfo.exists then
-              val sym = if symScore > 0 then sym1 else sym2
+              val sym = if symScore >= 0 then sym1 else sym2
               JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
             else if symScore == 2 then denot1
             else if symScore == -2 then denot2

From 81f5c30bda2b05385258bc2d1f9eaffb89ff8044 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 4 Jun 2020 10:16:32 +0200
Subject: [PATCH 19/20] Use symbol signature also for TERMREFin

---
 .../src/dotty/tools/dotc/core/tasty/TreePickler.scala  | 10 ++++------
 .../dotty/tools/dotc/core/tasty/TreeUnpickler.scala    |  6 +++---
 tasty/src/dotty/tools/tasty/TastyFormat.scala          | 10 +++++-----
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 1d6130e22113..7f275cec0f03 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -174,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)) {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index fbf123f168cc..5db42f5f9a1c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -331,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
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 682f067926a0..61976af89d96 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -123,7 +123,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   TERMREFsymbol         sym_ASTRef qual_Type                       -- A reference `qual.sym` to a local member with prefix `qual`
                   TERMREFpkg            fullyQualified_NameRef                     -- A reference to a package member with given fully qualified name
                   TERMREF               possiblySigned_NameRef qual_Type           -- A reference `qual.name` to a non-local member
-                  TERMREFin      Length possiblySigned_NameRef qual_Type namespace_Type -- A reference `qual.name` to a non-local member that's private in `namespace`
+                  TERMREFin      Length possiblySigned_NameRef qual_Type owner_Type -- A reference `qual.name` referring to a non-local symbol declared in owner that has the given signature (see note below)
                   THIS                  clsRef_Type                                -- cls.this
                   RECthis               recType_ASTRef                             -- The `this` in a recursive refined type `recType`.
                   SHAREDtype            path_ASTRef                                -- link to previously serialized path
@@ -213,9 +213,9 @@ Standard-Section: "ASTs" TopLevelStat*
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term             -- An annotation, given (class) type of constructor, and full application tree
 
-Note: The signature of a SELECTin node is the signature of the selected symbol, not
-      the signature of the reference. The latter undergoes an asSeenFrom but the former
-      does not. TODO: Also use symbol signatures in TERMREFin
+Note: The signature of a SELECTin or TERMREFin node is the signature of the selected symbol,
+      not the signature of the reference. The latter undergoes an asSeenFrom but the former
+      does not.
 
 Note: Tree tags are grouped into 5 categories that determine what follows, and thus allow to compute the size of the tagged tree in a generic way.
 
@@ -253,7 +253,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 22
+  val MajorVersion: Int = 23
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names, should update [[nameTagToString]] if a new constant is added */

From 19e658ca38f03961d5f8e8f4dff1832681548354 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 4 Jun 2020 10:44:20 +0200
Subject: [PATCH 20/20] Address other review comments

---
 .../scala/dotty/communitybuild/CommunityBuildTest.scala   | 1 +
 .../src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala   | 8 +++++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
index e1dbd4eac735..bd8e3e3cd170 100644
--- a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
+++ b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
@@ -379,6 +379,7 @@ class CommunityBuildTest:
   @Test def scodecBits = projects.scodecBits.run()
   @Test def scodec = projects.scodec.run()
   @Test def scalaParserCombinators = projects.scalaParserCombinators.run()
+  // blocked on #9074
   //@Test def dottyCpsAsync = projects.dottyCpsAsync.run()
   @Test def scalaz = projects.scalaz.run()
   @Test def endpoints = projects.endpoints.run()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 5db42f5f9a1c..75b29cd4d78f 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1172,12 +1172,14 @@ class TreeUnpickler(reader: TastyReader,
               var sname = readName()
               val qual = readTerm()
               val owner = readType()
-              val prefix = qual.tpe.widenIfUnstable
+              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) =>
-                  makeSelect(qual, name, owner.decl(name).atSignature(sig).asSeenFrom(prefix))
+                  select(name, owner.decl(name).atSignature(sig))
                 case name =>
-                  makeSelect(qual, name, owner.decl(name).asSeenFrom(prefix))
+                  select(name, owner.decl(name))
             case REPEATED =>
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)