Fix hashing and equality for dependent types

Rework hashing and equality so that two isomorphic types are identified
even if they are dependent (i.e. have back edges from a BoundType such
as ParamRef or RecThis to its HKLambda or RecType

Method and PolyTypes are still generative.

This fixes scala#3965

Author: odersky

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

@@ -3,11 +3,17 @@ package core
 
 import Types._
 import scala.util.hashing.{ MurmurHash3 => hashing }
+import annotation.tailrec
 
 object Hashable {
 
-  class Binders(tp: BindingType, next: Binders)
-  class BinderPairs(tp1: BindingType, tp2: BindingType, next: BinderPairs)
+  class Binders(tp: BindingType, next: Binders) {
+    val hash: Int = if (next == null) 31 else next.hash * 41 + 31
+  }
+  class BinderPairs(tp1: BindingType, tp2: BindingType, next: BinderPairs) {
+    @tailrec final def matches(t1: Type, t2: Type): Boolean =
+      (t1 `eq` tp1) && (t2 `eq` tp2) || next != null && next.matches(t1, t2)
+  }
 
   /** A hash value indicating that the underlying type is not
    *  cached in uniques.
@@ -95,7 +101,7 @@ trait Hashable {
     finishHash(bs, hashing.mix(hashSeed, x1.hashCode), 1, tp2, tps3)
 
 
-  protected final def doHash(bs: Binders, x1: Int, x2: Int): Int =
+  protected final def doHash(x1: Int, x2: Int): Int =
     finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
 
   protected final def addDelta(elemHash: Int, delta: Int) =

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

@@ -1526,10 +1526,10 @@ object Types {
   trait BindingType extends Type {
 
     override def identityHash(bs: Binders) =
-      if (bs == null) super.identityHash(bs) else ???
+      if (bs == null) super.identityHash(bs) else bs.hash
 
     def equalBinder(that: BindingType, bs: BinderPairs): Boolean =
-      (this `eq` that) /* || ??? */
+      (this `eq` that) || bs != null && bs.matches(this, that)
   }
 
   /** A trait for proto-types, used as expected types in typer */
@@ -2360,7 +2360,7 @@ object Types {
       refacc.apply(false, tp)
     }
 
-    override def computeHash(bs: Binders) = doHash(bs, parent)
+    override def computeHash(bs: Binders) = doHash(new Binders(this, bs), parent)
 
     override def eql(that: Type) = that match {
       case that: RecType => parent.eq(that.parent)
@@ -2369,7 +2369,7 @@ object Types {
 
     override def iso(that: Any, bs: BinderPairs) = that match {
       case that: RecType =>
-        parent.equals(that.parent, bs/*!!!*/)
+        parent.equals(that.parent, new BinderPairs(this, that, bs))
       case _ => false
     }
 
@@ -2693,7 +2693,8 @@ object Types {
   abstract class HKLambda extends CachedProxyType with LambdaType {
     final override def underlying(implicit ctx: Context) = resType
 
-    final override def computeHash(bs: Binders) = doHash(bs, paramNames, resType, paramInfos)
+    final override def computeHash(bs: Binders) =
+      doHash(new Binders(this, bs), paramNames, resType, paramInfos)
 
     final override def eql(that: Type) = that match {
       case that: HKLambda =>
@@ -2709,7 +2710,7 @@ object Types {
       case that: HKLambda =>
         paramNames.eqElements(that.paramNames) &&
         companion.eq(that.companion) && {
-          val bs1 = bs
+          val bs1 = new BinderPairs(this, that, bs)
           paramInfos.equalElements(that.paramInfos, bs1) &&
           resType.equals(that.resType, bs1)
         }
@@ -3210,7 +3211,7 @@ object Types {
       else infos(paramNum)
     }
 
-    override def computeHash(bs: Binders) = doHash(bs, paramNum, binder.identityHash(bs))
+    override def computeHash(bs: Binders) = doHash(paramNum, binder.identityHash(bs))
 
     override def iso(that: Any, bs: BinderPairs) = that match {
       case that: ParamRef => binder.equalBinder(that.binder, bs) && paramNum == that.paramNum

tests/pos/i3965.scala

@@ -0,0 +1,19 @@
+trait Iterable[+A] extends  IterableOps[A, Iterable, Iterable[A]]
+trait IterableOps[+A, +CCop[_], +C]
+
+trait SortedSet[A] extends Iterable[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
+
+trait SortedSetOps[A, +CCss[X] <: SortedSet[X], +C <: SortedSetOps[A, CCss, C]]
+
+class TreeSet[A]
+  extends SortedSet[A]
+    with SortedSetOps[A, TreeSet, TreeSet[A]]
+
+class Test {
+  def optionSequence1[CCos[X] <: IterableOps[X, CCos, _], A](xs: CCos[Option[A]]): Option[CCos[A]] = ???
+  def optionSequence1[CC[X] <: SortedSet[X] with SortedSetOps[X, CC, CC[X]], A : Ordering](xs: CC[Option[A]]): Option[CC[A]] = ???
+
+  def test(xs2: TreeSet[Option[String]]) = {
+    optionSequence1(xs2)
+  }
+}

tests/pos/i3965a.scala

@@ -0,0 +1,15 @@
+trait SortedSet[A] extends SortedSetOps[A, SortedSet, SortedSet[A]]
+
+trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+
+class TreeSet[A]
+  extends SortedSet[A]
+    with SortedSetOps[A, TreeSet, TreeSet[A]]
+
+class Test {
+  def optionSequence1[CC[X] <: SortedSet[X] with SortedSetOps[X, CC, CC[X]], A : Ordering](xs: CC[A]): Unit = ()
+
+  def test(xs2: TreeSet[String]) = {
+    optionSequence1(xs2)
+  }
+}