Less aggressive monomorphism for flow nodes

ahejlsberg · ahejlsberg · commit 19f1d3ba0a8c · 2019-08-09T12:35:28.000+02:00
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -148,8 +148,8 @@ namespace ts {
         let Symbol: new (flags: SymbolFlags, name: __String) => Symbol; // tslint:disable-line variable-name
         let classifiableNames: UnderscoreEscapedMap<true>;
 
-        const unreachableFlow = createFlowNode(FlowFlags.Unreachable, /*antecedent*/ undefined, /*node*/ undefined);
-        const reportedUnreachableFlow: FlowNode = createFlowNode(FlowFlags.Unreachable, /*antecedent*/ undefined, /*node*/ undefined);
+        const unreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };
+        const reportedUnreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };
 
         // state used to aggregate transform flags during bind.
         let subtreeTransformFlags: TransformFlags = TransformFlags.None;
@@ -560,7 +560,7 @@ namespace ts {
                 // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave
                 // similarly to break statements that exit to a label just past the statement body.
                 if (!isIIFE) {
-                    currentFlow = createFlowNode(FlowFlags.Start, /*antecedent*/ undefined, /*node*/ undefined) as FlowStart;
+                    currentFlow = { flags: FlowFlags.Start };
                     if (containerFlags & (ContainerFlags.IsFunctionExpression | ContainerFlags.IsObjectLiteralOrClassExpressionMethod)) {
                         currentFlow.node = <FunctionExpression | ArrowFunction | MethodDeclaration>node;
                     }
@@ -842,22 +842,12 @@ namespace ts {
             return isNarrowableReference(expr);
         }
 
-        function createFlowNode(flags: FlowFlags, antecedent: FlowNode | undefined, node: Node | undefined) {
-            return {
-                flags,
-                antecedent,
-                node,
-                id: undefined,
-                antecedents: undefined,
-            } as FlowNode;
-        }
-
         function createBranchLabel(): FlowLabel {
-            return createFlowNode(FlowFlags.BranchLabel, /*antecedent*/ undefined, /*node*/ undefined) as FlowLabel;
+            return { flags: FlowFlags.BranchLabel, antecedents: undefined };
         }
 
         function createLoopLabel(): FlowLabel {
-            return createFlowNode(FlowFlags.LoopLabel, /*antecedent*/ undefined, /*node*/ undefined) as FlowLabel;
+            return { flags: FlowFlags.LoopLabel, antecedents: undefined };
         }
 
         function setFlowNodeReferenced(flow: FlowNode) {
@@ -887,34 +877,30 @@ namespace ts {
                 return antecedent;
             }
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated(createFlowNode(flags, antecedent, expression));
+            return flowNodeCreated({ flags, antecedent, node: expression });
         }
 
         function createFlowSwitchClause(antecedent: FlowNode, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): FlowNode {
             if (!isNarrowingExpression(switchStatement.expression)) {
                 return antecedent;
             }
             setFlowNodeReferenced(antecedent);
-            const result = createFlowNode(FlowFlags.SwitchClause, antecedent, /*node*/ undefined) as FlowSwitchClause;
-            result.switchStatement = switchStatement;
-            result.clauseStart = clauseStart;
-            result.clauseEnd = clauseEnd;
-            return flowNodeCreated(result);
+            return flowNodeCreated({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd });
         }
 
         function createFlowAssignment(antecedent: FlowNode, node: Expression | VariableDeclaration | BindingElement): FlowNode {
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated(createFlowNode(FlowFlags.Assignment, antecedent, node));
+            return flowNodeCreated({ flags: FlowFlags.Assignment, antecedent, node });
         }
 
         function createFlowCall(antecedent: FlowNode, node: CallExpression): FlowNode {
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated(createFlowNode(FlowFlags.Call, antecedent, node));
+            return flowNodeCreated({ flags: FlowFlags.Call, antecedent, node });
         }
 
         function createFlowArrayMutation(antecedent: FlowNode, node: CallExpression | BinaryExpression): FlowNode {
             setFlowNodeReferenced(antecedent);
-            return flowNodeCreated(createFlowNode(FlowFlags.ArrayMutation, antecedent, node));
+            return flowNodeCreated({ flags: FlowFlags.ArrayMutation, antecedent, node });
         }
 
         function finishFlowLabel(flow: FlowLabel): FlowNode {
@@ -1192,8 +1178,7 @@ namespace ts {
                 //
                 // extra edges that we inject allows to control this behavior
                 // if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped.
-                const preFinallyFlow = createFlowNode(FlowFlags.PreFinally, preFinallyPrior, /*node*/ undefined) as PreFinallyFlow;
-                preFinallyFlow.lock = {};
+                const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preFinallyPrior, lock: {} };
                 addAntecedent(preFinallyLabel, preFinallyFlow);
 
                 currentFlow = finishFlowLabel(preFinallyLabel);
@@ -1212,7 +1197,7 @@ namespace ts {
                     }
                 }
                 if (!(currentFlow.flags & FlowFlags.Unreachable)) {
-                    const afterFinallyFlow = flowNodeCreated(createFlowNode(FlowFlags.AfterFinally, currentFlow, /*node*/ undefined) as AfterFinallyFlow);
+                    const afterFinallyFlow: AfterFinallyFlow = flowNodeCreated({ flags: FlowFlags.AfterFinally, antecedent: currentFlow });
                     preFinallyFlow.lock = afterFinallyFlow;
                     currentFlow = afterFinallyFlow;
                 }
@@ -1836,7 +1821,7 @@ namespace ts {
                 const host = getJSDocHost(typeAlias);
                 container = findAncestor(host.parent, n => !!(getContainerFlags(n) & ContainerFlags.IsContainer)) || file;
                 blockScopeContainer = getEnclosingBlockScopeContainer(host) || file;
-                currentFlow = createFlowNode(FlowFlags.Start, /*antecedent*/ undefined, /*node*/ undefined);
+                currentFlow = { flags: FlowFlags.Start };
                 parent = typeAlias;
                 bind(typeAlias.typeExpression);
                 if (isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === SyntaxKind.Identifier) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2578,7 +2578,7 @@ namespace ts {
 
     export interface FlowNodeBase {
         flags: FlowFlags;
-        id: number | undefined;     // Node id used by flow type cache in checker
+        id?: number;     // Node id used by flow type cache in checker
     }
 
     export interface FlowLock {

Original file line number	Diff line number	Diff line change
`@@ -2578,7 +2578,7 @@ namespace ts {`
`2578`	`2578`
`2579`	`2579`	`export interface FlowNodeBase {`
`2580`	`2580`	`flags: FlowFlags;`
`2581`		`- id: number \| undefined; // Node id used by flow type cache in checker`
	`2581`	`+ id?: number; // Node id used by flow type cache in checker`
`2582`	`2582`	`}`
`2583`	`2583`
`2584`	`2584`	`export interface FlowLock {`