Refactor realizability to also cache result of isStableRealizable

Author: Blaisorblade

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

@@ -70,22 +70,41 @@ class CheckRealizable(implicit ctx: Context) {
    */
   private def isLateInitialized(sym: Symbol) = sym.is(LateInitialized, butNot = Module)
 
-  /** The realizability status of given type `tp`*/
+  /** The realizability status of given type `tp` */
   def realizability(tp: Type): Realizability = tp.dealias match {
     case tp: TermRef =>
+      // Suppose tp is a.b.c.type, where c is declared with type T, then sym is c, tp.info is T and
+      // and tp.prefix is a.b.
       val sym = tp.symbol
-      val r =
-        if (sym.is(Stable)) realizability(tp.prefix)
-        else {
-          val r =
-            if (!sym.isStable) NotStable
-            else if (!isLateInitialized(sym)) realizability(tp.prefix)
-            else if (!sym.isEffectivelyFinal) new NotFinal(sym)
-            else realizability(tp.info).mapError(r => new ProblemInUnderlying(tp.info, r))
-          if (r == Realizable) sym.setFlag(Stable)
-          r
-        }
-      if (r == Realizable || tp.info.isStableRealizable) Realizable else r
+      // We know tp is realizable if either:
+      // 1. the symbol is stable and the prefix is realizable (so that, say, it contains no vars):
+      if (sym.is(Stable)) realizability(tp.prefix)
+      else {
+        // 2. if tp.info is a realizable singleton type. We check this last
+        // for performance, in all cases where some unrelated check might have failed.
+        def patchRealizability(r: Realizability) =
+          r.mapError(if (tp.info.isStableRealizable) Realizable else _)
+        val r =
+          if (!sym.isStable)
+            patchRealizability(NotStable)
+            // 3. If the symbol isn't "lazy" and its prefix is realizable
+          else if (!isLateInitialized(sym))
+            // XXX: This is a bit fishy: we only cache that the symbol is
+            // stable if it appears under a realizable prefix.
+            // XXX: Add object DependsOnPrefix extends Realizability(""), but filter it out here.
+            patchRealizability(realizability(tp.prefix))
+            // 4. If the symbol can't be overridden, and
+          else if (!sym.isEffectivelyFinal)
+            patchRealizability(new NotFinal(sym))
+          else
+            // Since patchRealizability checks realizability(tp.info) through
+            // isStableRealizable, using patchRealizability wouldn't make
+            // a difference, and calling it here again might introduce
+            // a slowdown exponential in the prefix length.
+            realizability(tp.info).mapError(r => new ProblemInUnderlying(tp.info, r))
+        if (r == Realizable) sym.setFlag(Stable)
+        r
+      }
     case _: SingletonType | NoPrefix =>
       Realizable
     case tp =>