Tweak signature update

Need to keep all consistent parts of original signature.

Author: odersky

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

@@ -311,14 +311,16 @@ object Denotations {
           case tp1: MethodOrPoly =>
             tp2 match {
               case tp2: MethodOrPoly =>
-                // Two remedial strategies
+                // 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 corresppnding parameter
                 //    and result types.

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

@@ -1,7 +1,7 @@
 package dotty.tools.dotc
 package core
 
-import Names._, Types._, Contexts._, StdNames._
+import Names._, Types._, Contexts._, StdNames._, Decorators._
 import TypeErasure.sigName
 
 import scala.annotation.tailrec
@@ -49,12 +49,19 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
     loop(this.paramsSig, that.paramsSig)
   }
 
-  /** Is this siganture consistent with that signature?
-   *  This is the case if the signatures have consistent parameters
-   *  and result types.
-   */
-  final def consistentWith(that: Signature): Boolean =
-    consistentParams(that) && consistent(resSig, that.resSig)
+  /** `that` signature, but keeping all corresponding parts of `this` signature. */
+  final def updateWith(that: Signature): Signature = {
+    def update(name1: TypeName, name2: TypeName): TypeName =
+      if (consistent(name1, name2)) name1 else name2
+    if (this == that) this
+    else if (!this.paramsSig.hasSameLengthAs(that.paramsSig)) that
+    else {
+      val mapped = Signature(
+          this.paramsSig.zipWithConserve(that.paramsSig)(update),
+          update(this.resSig, that.resSig))
+      if (mapped == this) this else mapped
+    }
+  }
 
   /** The degree to which this signature matches `that`.
    *  If parameter names are consistent and result types names match (i.e. they are the same

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

@@ -1870,10 +1870,13 @@ object Types {
     override def newLikeThis(prefix: Type)(implicit ctx: Context): TermRef = {
       // If symbol exists, the new signature is the symbol's signature as seen
       // from the new prefix, modulo consistency
-      val symSig =
-        if (symbol.exists) symbol.info.asSeenFrom(prefix, symbol.owner).signature
-        else sig
-      val newSig = if (sig.consistentWith(symSig)) sig else symSig
+      val newSig =
+        if (sig == Signature.NotAMethod || !symbol.exists)
+          sig
+        else
+          sig.updateWith(symbol.info.asSeenFrom(prefix, symbol.owner).signature)
+      if (newSig ne sig)
+        core.println(i"sig change at ${ctx.phase} for $this, pre = $prefix, sig: $sig --> $newSig")
       fixDenot(TermRef.withSig(prefix, name, newSig), prefix)
     }