apply the same fix in isPostSuperFlowNode

Author: Andarist

src/compiler/checker.ts

@@ -1426,7 +1426,7 @@ const enum IntrinsicTypeKind {
     NoInfer,
 }
 
-const enum FlowNodeReachableCacheFlags {
+const enum SharedFlowNodeCacheFlags {
     None = 0,
     Read = 1 << 0,
     Write = 1 << 1,
@@ -28111,7 +28111,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function isReachableFlowNode(flow: FlowNode) {
-        const result = isReachableFlowNodeWorker(flow, FlowNodeReachableCacheFlags.ReadWrite);
+        const result = isReachableFlowNodeWorker(flow, SharedFlowNodeCacheFlags.ReadWrite);
         lastFlowNode = flow;
         lastFlowNodeReachable = result;
         return result;
@@ -28125,26 +28125,26 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 );
     }
 
-    function isReachableFlowNodeWorker(flow: FlowNode, cacheFlags: FlowNodeReachableCacheFlags): boolean {
+    function isReachableFlowNodeWorker(flow: FlowNode, cacheFlags: SharedFlowNodeCacheFlags): boolean {
         while (true) {
             if (flow === lastFlowNode) {
                 return lastFlowNodeReachable;
             }
             const flags = flow.flags;
             if (flags & FlowFlags.Shared) {
-                if (cacheFlags & FlowNodeReachableCacheFlags.Read) {
+                if (cacheFlags & SharedFlowNodeCacheFlags.Read) {
                     const id = getFlowNodeId(flow);
                     let reachable = flowNodeReachable[id];
                     if (reachable !== undefined) {
                         return reachable;
                     }
-                    reachable = isReachableFlowNodeWorker(flow, cacheFlags & ~FlowNodeReachableCacheFlags.Read);
-                    if (cacheFlags & FlowNodeReachableCacheFlags.Write) {
+                    reachable = isReachableFlowNodeWorker(flow, cacheFlags & ~SharedFlowNodeCacheFlags.Read);
+                    if (cacheFlags & SharedFlowNodeCacheFlags.Write) {
                         flowNodeReachable[id] = reachable;
                     }
                     return reachable;
                 }
-                cacheFlags |= FlowNodeReachableCacheFlags.Read;
+                cacheFlags |= SharedFlowNodeCacheFlags.Read;
             }
             if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation)) {
                 flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation).antecedent;
@@ -28204,16 +28204,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     // Return true if the given flow node is preceded by a 'super(...)' call in every possible code path
     // leading to the node.
-    function isPostSuperFlowNode(flow: FlowNode, noCacheCheck: boolean): boolean {
+    function isPostSuperFlowNode(flow: FlowNode, cacheFlags: SharedFlowNodeCacheFlags): boolean {
         while (true) {
             const flags = flow.flags;
             if (flags & FlowFlags.Shared) {
-                if (!noCacheCheck) {
+                if (cacheFlags & SharedFlowNodeCacheFlags.Read) {
                     const id = getFlowNodeId(flow);
-                    const postSuper = flowNodePostSuper[id];
-                    return postSuper !== undefined ? postSuper : (flowNodePostSuper[id] = isPostSuperFlowNode(flow, /*noCacheCheck*/ true));
+                    let postSuper = flowNodePostSuper[id];
+                    if (postSuper !== undefined) {
+                        return postSuper;
+                    }
+                    postSuper = isPostSuperFlowNode(flow, cacheFlags & ~SharedFlowNodeCacheFlags.Read);
+                    if (cacheFlags & SharedFlowNodeCacheFlags.Write) {
+                        flowNodePostSuper[id] = postSuper;
+                    }
+                    return postSuper;
                 }
-                noCacheCheck = false;
+                cacheFlags |= SharedFlowNodeCacheFlags.Read;
             }
             if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause)) {
                 flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation | FlowSwitchClause).antecedent;
@@ -28226,7 +28233,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
             else if (flags & FlowFlags.BranchLabel) {
                 // A branching point is post-super if every branch is post-super.
-                return every((flow as FlowLabel).antecedent, f => isPostSuperFlowNode(f, /*noCacheCheck*/ false));
+                return every((flow as FlowLabel).antecedent, f => isPostSuperFlowNode(f, cacheFlags));
             }
             else if (flags & FlowFlags.LoopLabel) {
                 // A loop is post-super if the control flow path that leads to the top is post-super.
@@ -28236,7 +28243,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const target = (flow as FlowReduceLabel).node.target;
                 const saveAntecedents = target.antecedent;
                 target.antecedent = (flow as FlowReduceLabel).node.antecedents;
-                const result = isPostSuperFlowNode((flow as FlowReduceLabel).antecedent, /*noCacheCheck*/ false);
+                const result = isPostSuperFlowNode((flow as FlowReduceLabel).antecedent, SharedFlowNodeCacheFlags.None);
                 target.antecedent = saveAntecedents;
                 return result;
             }