Better caching of prototypes

 - Make IgnoredProto a cached type
 - Convert IgnroedProtos to WildcardTypes in wildApprox
 - Use `eql` instead of `equals` when hash-consing prototypes

Author: odersky

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

@@ -120,14 +120,22 @@ object ProtoTypes {
   }
 
   /** A class marking ignored prototypes that can be revealed by `deepenProto` */
-  case class IgnoredProto(ignored: Type) extends UncachedGroundType with MatchAlways:
+  abstract case class IgnoredProto(ignored: Type) extends CachedGroundType with MatchAlways:
     override def revealIgnored = ignored
     override def deepenProto(using Context): Type = ignored
 
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, ignored)
+
+    override def eql(that: Type): Boolean = that match
+      case that: IgnoredProto => ignored eq that.ignored
+      case _ => false
+
+  final class CachedIgnoredProto(ignored: Type) extends IgnoredProto(ignored)
+
   object IgnoredProto:
     def apply(ignored: Type): IgnoredProto = ignored match
       case ignored: IgnoredProto => ignored
-      case _ => new IgnoredProto(ignored)
+      case _ => CachedIgnoredProto(ignored)
 
   /** A prototype for expressions [] that are part of a selection operation:
    *
@@ -185,13 +193,6 @@ object ProtoTypes {
       if ((name eq this.name) && (memberProto eq this.memberProto) && (compat eq this.compat)) this
       else SelectionProto(name, memberProto, compat, privateOK)
 
-    override def equals(that: Any): Boolean = that match {
-      case that: SelectionProto =>
-        (name eq that.name) && (memberProto == that.memberProto) && (compat eq that.compat) && (privateOK == that.privateOK)
-      case _ =>
-        false
-    }
-
     def map(tm: TypeMap)(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
     def fold[T](x: T, ta: TypeAccumulator[T])(using Context): T = ta(x, memberProto)
 
@@ -201,6 +202,13 @@ object ProtoTypes {
       val delta = (if (compat eq NoViewsAllowed) 1 else 0) | (if (privateOK) 2 else 0)
       addDelta(doHash(bs, name, memberProto), delta)
     }
+
+    override def eql(that: Type): Boolean = that match {
+      case that: SelectionProto =>
+        (name eq that.name) && (memberProto eq that.memberProto) && (compat eq that.compat) && (privateOK == that.privateOK)
+      case _ =>
+        false
+    }
   }
 
   class CachedSelectionProto(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)
@@ -450,6 +458,9 @@ object ProtoTypes {
 
   class CachedViewProto(argType: Type, resultType: Type) extends ViewProto(argType, resultType) {
     override def computeHash(bs: Hashable.Binders): Int = doHash(bs, argType, resultType)
+    override def eql(that: Type): Boolean = that match
+      case that: ViewProto => (argType eq that.argType) && (resType eq that.resType)
+      case _ => false
   }
 
   object ViewProto {
@@ -680,6 +691,8 @@ object ProtoTypes {
       tp.derivedViewProto(
           wildApprox(tp.argType, theMap, seen, internal),
           wildApprox(tp.resultType, theMap, seen, internal))
+    case tp: IgnoredProto =>
+      WildcardType
     case  _: ThisType | _: BoundType => // default case, inlined for speed
       tp
     case tl: TypeLambda =>