Workaround #4819: Avoid creating incorrect JointRefDenotations

When merging a denotation with a PolyType and a denotation with a
MethodType, `infoMeet` will return the MethodType info, but the symbol
that is then used to create the `JointRefDenotation` can come from
either denotation, if it comes from the PolyType one, the resulting
denotation is inconsistent, this resulted in RefChecks errors.

We fix this by simply returning either of the denotation when `infoMeet`
returning either of their info. This is only a workaround and not a
proper fix for #4819 as it doesn't allow tests/neg/i4819.scala to
compile, see the comments in the file.

Author: smarter

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

@@ -525,9 +525,6 @@ 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 jointInfo =
               try infoMeet(info1, info2)
               catch {
@@ -542,7 +539,14 @@ object Denotations {
                   // 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)
+            if (jointInfo eq info1) denot1
+            else if (jointInfo eq info2) denot2
+            else {
+              val sym =
+                if (preferSym(sym2, sym1)) sym2
+                else sym1
+              new JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor)
+            }
           }
         }
       }

tests/neg/i4819.scala

@@ -0,0 +1,16 @@
+trait One[X]  {
+  def concat(suffix: Int): X = ???
+}
+
+trait Two[Y <: Foo] {
+  def concat[Dummy](suffix: Int): Y = ???
+}
+
+class Foo extends One[Foo] with Two[Foo] {
+  concat(0) // OK
+
+  // TODO: This does not typecheck because the polymorphic overload is masked
+  // (we merge the denotations for both overloads into one and always prefer
+  // MethodType to PolyType, instead we should return a MultiDenotation). See #4819.
+  concat[Int](0) // error (that should actually not be an error)
+}

tests/pos/i4819.scala

@@ -0,0 +1,12 @@
+trait One[X]  {
+  def concat(suffix: Int): X = ???
+}
+
+trait Two[Y <: Foo] {
+  def concat[Dummy](suffix: Int): Y = ???
+}
+
+class Foo extends One[Foo] with Two[Foo] {
+  concat(0) // OK
+  // See also tests/neg/i4819.scala
+}