Override isStable in child classes instead of using pattern matching

Author: mbovel

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

@@ -160,24 +160,7 @@ object Types {
       * Like in isStableMember, "stability" means idempotence.
       * Rationale: If an expression has a stable type, the expression must be idempotent, so stable types
       * must be singleton types of stable expressions. */
-    final def isStable(using Context): Boolean = stripTypeVar match {
-      case tp: TermRef => tp.cachedIsStable
-      case _: SingletonType | NoPrefix => true
-      case tp: RefinedOrRecType => tp.parent.isStable
-      case tp: ExprType => tp.resultType.isStable
-      case tp: AnnotatedType =>
-        // NOTE UncheckedStableAnnot was originally meant to be put on fields,
-        // not on types. Allowing it on types is a Scala 3 extension. See:
-        // https://www.scala-lang.org/files/archive/spec/2.11/11-annotations.html#scala-compiler-annotations
-        tp.annot.symbol == defn.UncheckedStableAnnot || tp.parent.isStable
-      case tp: AndType =>
-        // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing
-        // see: tests/explicit-nulls/pos/flow-stable.scala.disabled
-        tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
-        tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
-      case tp: AppliedType => tp.cachedIsStable
-      case _ => false
-    }
+    def isStable(using Context): Boolean = false
 
     /** Is this type a (possibly refined or applied or aliased) type reference
      *  to the given type symbol?
@@ -2035,6 +2018,7 @@ object Types {
    */
   trait SingletonType extends TypeProxy with ValueType {
     def isOverloaded(using Context): Boolean = false
+    override def isStable(using Context): Boolean = true
   }
 
   /** A trait for types that bind other types that refer to them.
@@ -2668,7 +2652,7 @@ object Types {
     var myIsStablePeriod: Period = Nowhere
     var myIsStable: Boolean = false
 
-    private[Types] def cachedIsStable(using Context): Boolean =
+    override def isStable(using Context): Boolean =
       if myIsStablePeriod != ctx.period then
         val isStable: Boolean = symbol.isStableMember && prefix.isStable || info.isStable
         if !isProvisional then
@@ -2957,6 +2941,7 @@ object Types {
 
   abstract class RefinedOrRecType extends CachedProxyType with ValueType {
     def parent: Type
+    override def isStable(using Context): Boolean = parent.isStable
   }
 
   /** A refined type parent { refinement }
@@ -3201,6 +3186,12 @@ object Types {
       case that: AndType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
       case _ => false
     }
+
+    override def isStable(using Context): Boolean =
+      // TODO: fix And type check when tp contains type parames for explicit-nulls flow-typing
+      // see: tests/explicit-nulls/pos/flow-stable.scala.disabled
+      tp1.isStable && (realizability(tp2) eq Realizable) ||
+      tp2.isStable && (realizability(tp1) eq Realizable)
   }
 
   final class CachedAndType(tp1: Type, tp2: Type) extends AndType(tp1, tp2)
@@ -3427,6 +3418,8 @@ object Types {
       case that: ExprType => resType.eq(that.resType)
       case _ => false
     }
+    
+    override def isStable(using Context): Boolean = resultType.isStable
 
     // equals comes from case class; no matching override is needed
 
@@ -4182,7 +4175,7 @@ object Types {
       if myGround == 0 then myGround = if acc.foldOver(true, this) then 1 else -1
       myGround > 0
 
-    private[Types] def cachedIsStable(using Context): Boolean =
+    override def isStable(using Context): Boolean =
       if myIsStablePeriod != ctx.period then
         val res = tycon match
           case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) && args.forall(_.isStable) => true
@@ -4825,6 +4818,8 @@ object Types {
 
     override def stripped(using Context): Type = stripTypeVar.stripped
 
+    override def isStable(using Context): Boolean = stripTypeVar.isStable
+
     /** If the variable is instantiated, its instance, otherwise its origin */
     override def underlying(using Context): Type = {
       val inst = instanceOpt
@@ -5273,6 +5268,13 @@ object Types {
       isRefiningCache
     }
 
+    override def isStable(using Context): Boolean = stripTypeVar match
+      case AnnotatedType(parent, annot) =>
+        // NOTE UncheckedStableAnnot was originally meant to be put on fields,
+        // not on types. Allowing it on types is a Scala 3 extension. See:
+        // https://www.scala-lang.org/files/archive/spec/2.11/11-annotations.html#scala-compiler-annotations
+        annot.symbol == defn.UncheckedStableAnnot || parent.isStable
+
     // equals comes from case class; no matching override is needed
 
     override def computeHash(bs: Binders): Int =
@@ -5328,6 +5330,7 @@ object Types {
   /** Missing prefix */
   @sharable case object NoPrefix extends CachedGroundType {
     override def computeHash(bs: Binders): Int = hashSeed
+    override def isStable(using Context): Boolean = true
   }
 
   /** A common superclass of `ErrorType` and `TryDynamicCallSite`. Instances of this