Fix inductive implicits performance regression

The fix for #6058 in #6163 caused a significant performance regression
in the inductive implicits benchmark because the use of =:= rather than
== in the divergence check was significantly slower. It is the right
test however, so we need a quicker check to rule out negative cases.

We're already computing the covering sets and sizes of the two types
being compared. tp1 =:= tp2 should entail (sz1 == sz2 && cs1 == cs2), so
the contrapositive (sz1 != sz2 || cs1 != cs2) should entail that !(tp1
=:= tp2). However the covering set and size computations were incorrect
(they missed types mentioned in bounds which should have been included,
and included symbols for unsolved type variables which should not).

This commit fixes the latter issue, which allows covering set and size
tests to be used to avoid expensive full type equality tests.

Author: milessabin

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

@@ -4973,6 +4973,14 @@ object Types {
         foldOver(n + 1, tp)
       case tp: TypeRef if tp.info.isTypeAlias =>
         apply(n, tp.superType)
+      case tp: TermRef =>
+        apply(n, tp.underlying)
+      case tp: TypeParamRef =>
+        ctx.typerState.constraint.entry(tp) match {
+          case tb: TypeBounds => foldOver(n, tb)
+          case NoType => foldOver(n, tp.underlying)
+          case inst => foldOver(n, inst)
+        }
       case _ =>
         foldOver(n, tp)
     }
@@ -4990,10 +4998,18 @@ object Types {
           foldOver(cs + sym, tp)
         case tp: TypeRef if tp.info.isTypeAlias =>
           apply(cs, tp.superType)
-        case tp: TypeBounds =>
-          foldOver(cs, tp)
-        case other =>
+        case tp: TypeRef if tp.prefix.isValueType =>
           foldOver(cs + sym, tp)
+        case tp: TermRef =>
+          apply(cs, tp.underlying)
+        case tp: TypeParamRef =>
+          ctx.typerState.constraint.entry(tp) match {
+            case tb: TypeBounds => foldOver(cs, tb)
+            case NoType => foldOver(cs, tp.underlying)
+            case inst => foldOver(cs, inst)
+          }
+        case other =>
+          foldOver(cs, tp)
       }
     }
   }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -1406,9 +1406,10 @@ abstract class SearchHistory { outer =>
           if (cand1.ref == cand.ref) {
             val wideTp = tp.widenExpr
             lazy val wildTp = wildApprox(wideTp)
+            lazy val tpSize = wideTp.typeSize
             if (belowByname && (wildTp <:< wildPt)) false
-            else if ((wideTp.typeSize < ptSize && wideTp.coveringSet == ptCoveringSet) || (wildTp =:= wildPt)) true
-            else loop(tl, isByname(tp) || belowByname)
+            else if (tpSize > ptSize || wideTp.coveringSet != ptCoveringSet) loop(tl, isByname(tp) || belowByname)
+            else tpSize < ptSize || wildTp =:= wildPt || loop(tl, isByname(tp) || belowByname)
           }
           else loop(tl, isByname(tp) || belowByname)
       }