Cleanup of Signature matching

Eliminate sameParams, add comments.
Also, minor cleanups elsewhere.

Author: odersky

src/dotty/tools/dotc/config/Config.scala

@@ -77,10 +77,10 @@ object Config {
    */
   final val checkProjections = false
 
-  /** If this flag is set it is checked that &/| only apply to types
+  /** If this flag is set, it is checked that &/| only apply to types
    *  that are either both hk types or both * types. Should be used
-   *  only for debugging as there a generic class without arguments
-   *  can be produced in an And by Implicits.liftToClasses.
+   *  only for debugging as the assertion may be violated by Implicits.liftToClasses,
+   *  which can produce an And over a generic class without arguments.
    */
   final val checkKinds = false
 

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

@@ -473,7 +473,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     for {
       (poly, entries) <- boundsMap.toList
       n <- 0 until paramCount(entries)
-      if true || isBounds(entries(n))
+      if isBounds(entries(n))
     } yield PolyParam(poly, n)
 
   def forallParams(p: PolyParam => Boolean): Boolean = {

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

@@ -22,35 +22,40 @@ import TypeErasure.sigName
  *        "scala.String".toTypeName)
  *
  *  The signatures of non-method types are always `NotAMethod`.
+ *
+ *  There are three kinds of "missing" parts of signatures:
+ *
+ *   - tpnme.EMPTY          Result type marker for NotAMethod and OverloadedSignature
+ *   - tpnme.WILDCARD       Arises from a Wildcard or error type
+ *   - tpnme.Uninstantiated Arises from an uninstantiated type variable
  */
 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
+  /** Two names are consistent if they are the same or one of them is tpnme.Uninstantiated */
+  private def consistent(name1: TypeName, name2: TypeName) =
+    name1 == name2 || name1 == tpnme.Uninstantiated || name2 == tpnme.Uninstantiated
 
   /** Does this signature coincide with that signature on their parameter parts?
    *  This is the case if all parameter names are _consistent_, i.e. they are either
    *  equal or on of them is tpnme.Uninstantiated.
    */
   final def consistentParams(that: Signature): Boolean = {
-    def consistent(name1: TypeName, name2: TypeName) =
-      name1 == name2 || name1 == tpnme.Uninstantiated || name2 == tpnme.Uninstantiated
     def loop(names1: List[TypeName], names2: List[TypeName]): Boolean =
       if (names1.isEmpty) names2.isEmpty
       else names2.nonEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
     loop(this.paramsSig, that.paramsSig)
   }
 
   /** The degree to which this signature matches `that`.
-   *  If both parameter and result type names match (i.e. they are the same
+   *  If parameter names are consistent and result types 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
+   *  If only the parameter names are constistent, the result is `ParamMatch` before erasure and
    *  `NoMatch` otherwise.
-   *  If the parameters do not match, the result is always `NoMatch`.
+   *  If the parameters are inconsistent, the result is always `NoMatch`.
    */
   final def matchDegree(that: Signature)(implicit ctx: Context): MatchDegree =
-    if (sameParams(that))
+    if (consistentParams(that))
       if (resSig == that.resSig || isWildcard(resSig) || isWildcard(that.resSig)) FullMatch
       else if (!ctx.erasedTypes) ParamMatch
       else NoMatch

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

@@ -431,7 +431,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp2 @ MethodType(_, formals2) =>
       def compareMethod = tp1 match {
         case tp1 @ MethodType(_, formals1) =>
-          (tp1.signature sameParams tp2.signature) &&
+          (tp1.signature consistentParams tp2.signature) &&
             matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
             tp1.isImplicit == tp2.isImplicit && // needed?
             isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
@@ -442,7 +442,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp2: PolyType =>
       def comparePoly = tp1 match {
         case tp1: PolyType =>
-          (tp1.signature sameParams tp2.signature) &&
+          (tp1.signature consistentParams tp2.signature) &&
             matchingTypeParams(tp1, tp2) &&
             isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
         case _ =>