Revert "More efficient scheme for caching flow node reachability"

This reverts commit e97ebb7.

Author: ahejlsberg

src/compiler/checker.ts

@@ -6,7 +6,6 @@ namespace ts {
     let nextNodeId = 1;
     let nextMergeId = 1;
     let nextFlowId = 1;
-    let nextCheckerId = 1;
 
     const enum IterationUse {
         AllowsSyncIterablesFlag = 1 << 0,
@@ -299,7 +298,6 @@ namespace ts {
         let instantiationDepth = 0;
         let constraintDepth = 0;
         let currentNode: Node | undefined;
-        let checkerId: number;
 
         const emptySymbols = createSymbolTable();
         const identityMapper: (type: Type) => Type = identity;
@@ -844,6 +842,7 @@ namespace ts {
         const flowLoopTypes: Type[][] = [];
         const sharedFlowNodes: FlowNode[] = [];
         const sharedFlowTypes: FlowType[] = [];
+        const flowNodeReachable: (boolean | undefined)[] = [];
         const potentialThisCollisions: Node[] = [];
         const potentialNewTargetCollisions: Node[] = [];
         const awaitedTypeStack: number[] = [];
@@ -16994,21 +16993,17 @@ namespace ts {
         }
 
         function isReachableFlowNode(flow: FlowNode) {
-            return isReachableFlowNodeWorker(flow, /*noCacheCheck*/ false);
+            return isReachableFlowNodeWorker(flow, /*skipCacheCheck*/ false);
         }
 
         function isReachableFlowNodeWorker(flow: FlowNode, noCacheCheck: boolean): boolean {
             while (true) {
                 const flags = flow.flags;
-                if (flags & (FlowFlags.Shared | FlowFlags.Assignment | FlowFlags.Label)) {
+                if (flags & FlowFlags.Shared) {
                     if (!noCacheCheck) {
-                        if (flow.checkerId === checkerId) {
-                            return !!(flow.flags & FlowFlags.Reachable);
-                        }
-                        const reachable = isReachableFlowNodeWorker(flow, /*noCacheCheck*/ true);
-                        flow.checkerId = checkerId;
-                        flow.flags = (flow.flags & ~FlowFlags.Reachable) | (reachable ? FlowFlags.Reachable : 0);
-                        return reachable;
+                        const id = getFlowNodeId(flow);
+                        const reachable = flowNodeReachable[id];
+                        return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, /*skipCacheCheck*/ true));
                     }
                     noCacheCheck = false;
                 }
@@ -32292,9 +32287,6 @@ namespace ts {
         }
 
         function initializeTypeChecker() {
-            checkerId = nextCheckerId;
-            nextCheckerId++;
-
             // Bind all source files and propagate errors
             for (const file of host.getSourceFiles()) {
                 bindSourceFile(file, compilerOptions);

src/compiler/types.ts

@@ -2582,8 +2582,6 @@ namespace ts {
         AfterFinally   = 1 << 13, // Injected edge that links post-finally flow with the rest of the graph
         /** @internal */
         Cached         = 1 << 14, // Indicates that at least one cross-call cache entry exists for this node, even if not a loop participant
-        /** @internal */
-        Reachable      = 1 << 15, // Reachability as computed by isReachableFlowNode
         Label = BranchLabel | LoopLabel,
         Condition = TrueCondition | FalseCondition
     }
@@ -2602,8 +2600,6 @@ namespace ts {
     export interface FlowNodeBase {
         flags: FlowFlags;
         id?: number;     // Node id used by flow type cache in checker
-        /** @internal */
-        checkerId?: number;  // Checker id for FlowFlags.Reachable
     }
 
     export interface FlowLock {