Cache Type#isStable (experiment)

Author: mbovel

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

@@ -100,7 +100,9 @@ object Types {
 //    }
 
     /** A cache indicating whether the type was still provisional, last time we checked */
-    @sharable private var mightBeProvisional = true
+    @sharable private var mightBeProvisional: Boolean = true
+
+    @sharable private var myIsStable: Byte = 0
 
     /** Is this type still provisional? This is the case if the type contains, or depends on,
      *  uninstantiated type variables or type symbols that have the Provisional flag set.
@@ -160,12 +162,20 @@ 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 {
+    final def isStable(using Context): Boolean =
+      if myIsStable == 0 then
+        val isStable = computeIsStable()
+        if !isProvisional then
+          myIsStable = if isStable then 1 else -1
+        isStable
+      else
+        myIsStable > 0
+      
+    private final def computeIsStable()(using Context): Boolean = stripTypeVar match
       case tp: TermRef => tp.symbol.isStableMember && tp.prefix.isStable || tp.info.isStable
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
-      case tp: AppliedType => tp.appliedTypeIsStable
       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:
@@ -176,8 +186,10 @@ object Types {
         // 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.tycon match
+        case tycon: TypeRef => defn.isCompiletimeAppliedType(tycon.symbol) && tp.args.forall(_.isStable)
+        case _ => false
       case _ => false
-    }
 
     /** Is this type a (possibly refined or applied or aliased) type reference
      *  to the given type symbol?
@@ -4161,23 +4173,11 @@ object Types {
     // Boolean caches: 0 = uninitialized, -1 = false, 1 = true
     private var myStableHash: Byte = 0
     private var myGround: Byte = 0
-    private var myIsStable: Byte = 0
-
 
     def isGround(acc: TypeAccumulator[Boolean])(using Context): Boolean =
       if myGround == 0 then myGround = if acc.foldOver(true, this) then 1 else -1
       myGround > 0
 
-    inline def appliedTypeIsStable(using Context): Boolean =
-      if myIsStable == 0 then
-        val isStable: Byte = tycon match
-          case tycon: TypeRef if defn.isCompiletimeAppliedType(tycon.symbol) && args.forall(_.isStable) => 1
-          case _ => -1
-        if !isProvisional then myIsStable = isStable
-        isStable > 0
-      else
-        myIsStable > 0
-
     override def underlying(using Context): Type = tycon
 
     override def superType(using Context): Type =