Refinements to signature matching

1) Matching after erasure also takes wildcards into account
(before it didn't).

2) Combine all signature matching operations into a single matchDegree method.

Author: odersky

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

@@ -269,52 +269,49 @@ object Denotations {
           }
         case denot1: SingleDenotation =>
           if (denot1 eq denot2) denot1
-          else {
+          else if (denot1.matches(denot2)) {
             val info1 = denot1.info
             val info2 = denot2.info
-            if (denot1.signature.matches(denot2.signature) &&
-                denot1.info.matches(denot2.info)) {
-              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 => true
-                }
-                sym1.derivesFrom(sym2) ||
-                  !sym2.derivesFrom(sym1) && precedesIn(pre.baseClasses)
+            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 => true
               }
+              sym1.derivesFrom(sym2) ||
+                !sym2.derivesFrom(sym1) && precedesIn(pre.baseClasses)
+            }
 
-              /** Preference according to partial pre-order (isConcrete, precedes) */
-              def preferSym(sym1: Symbol, sym2: Symbol) =
-                sym1.eq(sym2) ||
-                  sym1.isAsConcrete(sym2) &&
-                  (!sym2.isAsConcrete(sym1) || precedes(sym1.owner, sym2.owner))
+            /** Preference according to partial pre-order (isConcrete, precedes) */
+            def preferSym(sym1: Symbol, sym2: Symbol) =
+              sym1.eq(sym2) ||
+                sym1.isAsConcrete(sym2) &&
+                (!sym2.isAsConcrete(sym1) || precedes(sym1.owner, sym2.owner))
 
-              /** Sym preference provided types also override */
-              def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
-                preferSym(sym1, sym2) && info1.overrides(info2)
+            /** Sym preference provided types also override */
+            def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
+              preferSym(sym1, sym2) && info1.overrides(info2)
 
-              if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
+            if (sym2Accessible && prefer(sym2, sym1, info2, info1)) denot2
+            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 {
-                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 {
-                  val sym =
-                    if (!sym1.exists) sym2
-                    else if (!sym2.exists) sym1
-                    else if (preferSym(sym2, sym1)) sym2
-                    else sym1
-                  new JointRefDenotation(sym, info1 & info2, denot1.validFor & denot2.validFor)
-                }
+                val sym =
+                  if (!sym1.exists) sym2
+                  else if (!sym2.exists) sym1
+                  else if (preferSym(sym2, sym1)) sym2
+                  else sym1
+                new JointRefDenotation(sym, info1 & info2, denot1.validFor & denot2.validFor)
               }
-            } else NoDenotation
-          }
+            }
+          } else NoDenotation
       }
 
       if (this eq that) this
@@ -472,14 +469,16 @@ object Denotations {
 
     def atSignature(sig: Signature, site: Type, relaxed: Boolean)(implicit ctx: Context): SingleDenotation = {
       val situated = if (site == NoPrefix) this else asSeenFrom(site)
-      val matches =
-        if (relaxed) sig.matches(situated.signature)
-        else sig.matchesFully(situated.signature)
+      val matches = sig.matchDegree(situated.signature) >=
+        (if (relaxed) Signature.ParamMatch else Signature.FullMatch)
       if (matches) this else NoDenotation
     }
 
-    def matches(other: SingleDenotation)(implicit ctx: Context): Boolean =
-      signature.matches(other.signature) && info.matches(other.info)
+    def matches(other: SingleDenotation)(implicit ctx: Context): Boolean = {
+      val d = signature.matchDegree(other.signature)
+      d == Signature.FullMatch ||
+      d >= Signature.ParamMatch && info.matches(other.info)
+    }
 
     // ------ Forming types -------------------------------------------
 
@@ -788,7 +787,7 @@ object Denotations {
     final def toDenot(pre: Type)(implicit ctx: Context): Denotation = this
     final def containsSym(sym: Symbol): Boolean = hasUniqueSym && (symbol eq sym)
     final def containsSig(sig: Signature)(implicit ctx: Context) =
-      exists && (signature matches sig)
+      exists && signature.matchDegree(sig) >= Signature.ParamMatch
     final def filterWithPredicate(p: SingleDenotation => Boolean): SingleDenotation =
       if (p(this)) this else NoDenotation
     final def filterDisjoint(denots: PreDenotation)(implicit ctx: Context): SingleDenotation =

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

@@ -24,23 +24,24 @@ import TypeErasure.sigName
  *  The signatures of non-method types are always `NotAMethod`.
  */
 case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
+  import Signature._
 
   /** Does this signature coincide with that signature on their parameter parts? */
   final def sameParams(that: Signature): Boolean = this.paramsSig == that.paramsSig
 
-  /** The meaning of `matches` depends on the phase. If types are not erased,
-   *  it means `sameParams`. Once types are erased, it means `==`, comparing parameter as
-   *  well as result type parts.
+  /** The degree to which this signature matches `that`.
+   *  If both parameter and result type names match (i.e. they are the same
+   *  or one is a wildcard), the result is `FullMatch`.
+   *  If only the parameter names match, the result is `ParamMatch` before erasure and
+   *  `NoMatch` otherwise.
+   *  If the parameters do not match, the result is always `NoMatch`.
    */
-  final def matches(that: Signature)(implicit ctx: Context) =
-    if (ctx.erasedTypes) equals(that) else sameParams(that)
-
-  /** A signature matches fully another if it has the same parameter type names
-   *  and either one of the result type names is a wildcard or both agree.
-   */
-  final def matchesFully(that: Signature)(implicit ctx: Context) =
-    this.paramsSig == that.paramsSig &&
-    (isWildcard(this.resSig) || isWildcard(that.resSig) || this.resSig == that.resSig)
+  final def matchDegree(that: Signature)(implicit ctx: Context): MatchDegree =
+    if (sameParams(that))
+      if (resSig == that.resSig || isWildcard(resSig) || isWildcard(that.resSig)) FullMatch
+      else if (!ctx.erasedTypes) ParamMatch
+      else NoMatch
+    else NoMatch
 
   /** name.toString == "" or name.toString == "_" */
   private def isWildcard(name: TypeName) = name.isEmpty || name == tpnme.WILDCARD
@@ -55,6 +56,11 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
 
 object Signature {
 
+  type MatchDegree = Int
+  val NoMatch = 0
+  val ParamMatch = 1
+  val FullMatch = 2
+
   /** The signature of everything that's not a method, i.e. that has
    *  a type different from PolyType, MethodType, or ExprType.
    */

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -369,7 +369,7 @@ object RefChecks {
             clazz.info.nonPrivateMember(sym.name).hasAltWith { alt =>
               alt.symbol.is(JavaDefined, butNot = Deferred) &&
                 !sym.owner.derivesFrom(alt.symbol.owner) &&
-                alt.signature.matches(sym.signature)
+                alt.matches(sym)
             }
           }