Add isForInOrOfStatement utility (microsoft#16455)

Andy · web-flow · commit 2748b3b334d7 · 2017-06-12T11:08:41.000-07:00
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -612,7 +612,7 @@ namespace ts {
                     break;
                 case SyntaxKind.ForInStatement:
                 case SyntaxKind.ForOfStatement:
-                    bindForInOrForOfStatement(<ForInStatement | ForOfStatement>node);
+                    bindForInOrForOfStatement(<ForInOrOfStatement>node);
                     break;
                 case SyntaxKind.IfStatement:
                     bindIfStatement(<IfStatement>node);
@@ -950,7 +950,7 @@ namespace ts {
             currentFlow = finishFlowLabel(postLoopLabel);
         }
 
-        function bindForInOrForOfStatement(node: ForInStatement | ForOfStatement): void {
+        function bindForInOrForOfStatement(node: ForInOrOfStatement): void {
             const preLoopLabel = createLoopLabel();
             const postLoopLabel = createBranchLabel();
             addAntecedent(preLoopLabel, currentFlow);
@@ -1328,7 +1328,7 @@ namespace ts {
 
         function bindVariableDeclarationFlow(node: VariableDeclaration) {
             bindEachChild(node);
-            if (node.initializer || node.parent.parent.kind === SyntaxKind.ForInStatement || node.parent.parent.kind === SyntaxKind.ForOfStatement) {
+            if (node.initializer || isForInOrOfStatement(node.parent.parent)) {
                 bindInitializedVariableFlow(node);
             }
         }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -804,16 +804,8 @@ namespace ts {
                         break;
                 }
 
-                switch (declaration.parent.parent.kind) {
-                    case SyntaxKind.ForInStatement:
-                    case SyntaxKind.ForOfStatement:
-                        // ForIn/ForOf case - use site should not be used in expression part
-                        if (isSameScopeDescendentOf(usage, (<ForInStatement | ForOfStatement>declaration.parent.parent).expression, container)) {
-                            return true;
-                        }
-                }
-
-                return false;
+                // ForIn/ForOf case - use site should not be used in expression part
+                return isForInOrOfStatement(declaration.parent.parent) && isSameScopeDescendentOf(usage, declaration.parent.parent.expression, container);
             }
 
             function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node, container?: Node): boolean {
@@ -19588,9 +19580,7 @@ namespace ts {
         function errorUnusedLocal(node: Node, name: string) {
             if (isIdentifierThatStartsWithUnderScore(node)) {
                 const declaration = getRootDeclaration(node.parent);
-                if (declaration.kind === SyntaxKind.VariableDeclaration &&
-                    (declaration.parent.parent.kind === SyntaxKind.ForInStatement ||
-                    declaration.parent.parent.kind === SyntaxKind.ForOfStatement)) {
+                if (declaration.kind === SyntaxKind.VariableDeclaration && isForInOrOfStatement(declaration.parent.parent)) {
                     return;
                 }
             }
@@ -20283,7 +20273,7 @@ namespace ts {
             }
         }
 
-        function checkForInOrForOfVariableDeclaration(iterationStatement: ForInStatement | ForOfStatement): void {
+        function checkForInOrForOfVariableDeclaration(iterationStatement: ForInOrOfStatement): void {
             const variableDeclarationList = <VariableDeclarationList>iterationStatement.initializer;
             // checkGrammarForInOrForOfStatement will check that there is exactly one declaration.
             if (variableDeclarationList.declarations.length >= 1) {
@@ -24263,7 +24253,7 @@ namespace ts {
             }
         }
 
-        function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInStatement | ForOfStatement): boolean {
+        function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInOrOfStatement): boolean {
             if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {
                 return true;
             }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1708,6 +1708,8 @@ namespace ts {
         incrementor?: Expression;
     }
 
+    export type ForInOrOfStatement = ForInStatement | ForOfStatement;
+
     export interface ForInStatement extends IterationStatement {
         kind: SyntaxKind.ForInStatement;
         initializer: ForInitializer;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1627,7 +1627,7 @@ namespace ts {
                     return unaryOperator === SyntaxKind.PlusPlusToken || unaryOperator === SyntaxKind.MinusMinusToken ? AssignmentKind.Compound : AssignmentKind.None;
                 case SyntaxKind.ForInStatement:
                 case SyntaxKind.ForOfStatement:
-                    return (<ForInStatement | ForOfStatement>parent).initializer === node ? AssignmentKind.Definite : AssignmentKind.None;
+                    return (<ForInOrOfStatement>parent).initializer === node ? AssignmentKind.Definite : AssignmentKind.None;
                 case SyntaxKind.ParenthesizedExpression:
                 case SyntaxKind.ArrayLiteralExpression:
                 case SyntaxKind.SpreadElement:
@@ -5152,6 +5152,11 @@ namespace ts {
         return false;
     }
 
+    /* @internal */
+    export function isForInOrOfStatement(node: Node): node is ForInOrOfStatement {
+        return node.kind === SyntaxKind.ForInStatement || node.kind === SyntaxKind.ForOfStatement;
+    }
+
     // Element
 
     /* @internal */
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
@@ -1198,9 +1198,9 @@ namespace ts {
 
             case SyntaxKind.ForInStatement:
             case SyntaxKind.ForOfStatement:
-                result = reduceNode((<ForInStatement | ForOfStatement>node).initializer, cbNode, result);
-                result = reduceNode((<ForInStatement | ForOfStatement>node).expression, cbNode, result);
-                result = reduceNode((<ForInStatement | ForOfStatement>node).statement, cbNode, result);
+                result = reduceNode((<ForInOrOfStatement>node).initializer, cbNode, result);
+                result = reduceNode((<ForInOrOfStatement>node).expression, cbNode, result);
+                result = reduceNode((<ForInOrOfStatement>node).statement, cbNode, result);
                 break;
 
             case SyntaxKind.ReturnStatement:
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
@@ -1053,7 +1053,7 @@ namespace Harness {
         ];
 
         let optionsIndex: ts.Map<ts.CommandLineOption>;
-        function getCommandLineOption(name: string): ts.CommandLineOption {
+        function getCommandLineOption(name: string): ts.CommandLineOption | undefined {
             if (!optionsIndex) {
                 optionsIndex = ts.createMap<ts.CommandLineOption>();
                 const optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
@@ -146,7 +146,7 @@ namespace ts.BreakpointResolver {
 
                     case SyntaxKind.ForOfStatement:
                         // span in initializer
-                        return spanInInitializerOfForLike(<ForOfStatement | ForInStatement>node);
+                        return spanInInitializerOfForLike(<ForOfStatement>node);
 
                     case SyntaxKind.SwitchStatement:
                         // span on switch(...)

Original file line number	Diff line number	Diff line change
`@@ -804,16 +804,8 @@ namespace ts {`
`804`	`804`	`break;`
`805`	`805`	`}`
`806`	`806`
`807`		`- switch (declaration.parent.parent.kind) {`
`808`		`- case SyntaxKind.ForInStatement:`
`809`		`- case SyntaxKind.ForOfStatement:`
`810`		`- // ForIn/ForOf case - use site should not be used in expression part`
`811`		`- if (isSameScopeDescendentOf(usage, (<ForInStatement \| ForOfStatement>declaration.parent.parent).expression, container)) {`
`812`		`- return true;`
`813`		`- }`
`814`		`- }`
`815`		`-`
`816`		`- return false;`
	`807`	`+ // ForIn/ForOf case - use site should not be used in expression part`
	`808`	`+ return isForInOrOfStatement(declaration.parent.parent) && isSameScopeDescendentOf(usage, declaration.parent.parent.expression, container);`
`817`	`809`	`}`
`818`	`810`
`819`	`811`	`function isUsedInFunctionOrInstanceProperty(usage: Node, declaration: Node, container?: Node): boolean {`
`@@ -19588,9 +19580,7 @@ namespace ts {`
`19588`	`19580`	`function errorUnusedLocal(node: Node, name: string) {`
`19589`	`19581`	`if (isIdentifierThatStartsWithUnderScore(node)) {`
`19590`	`19582`	`const declaration = getRootDeclaration(node.parent);`
`19591`		`- if (declaration.kind === SyntaxKind.VariableDeclaration &&`
`19592`		`- (declaration.parent.parent.kind === SyntaxKind.ForInStatement \|\|`
`19593`		`- declaration.parent.parent.kind === SyntaxKind.ForOfStatement)) {`
	`19583`	`+ if (declaration.kind === SyntaxKind.VariableDeclaration && isForInOrOfStatement(declaration.parent.parent)) {`
`19594`	`19584`	`return;`
`19595`	`19585`	`}`
`19596`	`19586`	`}`
`@@ -20283,7 +20273,7 @@ namespace ts {`
`20283`	`20273`	`}`
`20284`	`20274`	`}`
`20285`	`20275`
`20286`		`- function checkForInOrForOfVariableDeclaration(iterationStatement: ForInStatement \| ForOfStatement): void {`
	`20276`	`+ function checkForInOrForOfVariableDeclaration(iterationStatement: ForInOrOfStatement): void {`
`20287`	`20277`	`const variableDeclarationList = <VariableDeclarationList>iterationStatement.initializer;`
`20288`	`20278`	`// checkGrammarForInOrForOfStatement will check that there is exactly one declaration.`
`20289`	`20279`	`if (variableDeclarationList.declarations.length >= 1) {`
`@@ -24263,7 +24253,7 @@ namespace ts {`
`24263`	`24253`	`}`
`24264`	`24254`	`}`
`24265`	`24255`
`24266`		`- function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInStatement \| ForOfStatement): boolean {`
	`24256`	`+ function checkGrammarForInOrForOfStatement(forInOrOfStatement: ForInOrOfStatement): boolean {`
`24267`	`24257`	`if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {`
`24268`	`24258`	`return true;`
`24269`	`24259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1708,6 +1708,8 @@ namespace ts {`
`1708`	`1708`	`incrementor?: Expression;`
`1709`	`1709`	`}`
`1710`	`1710`
	`1711`	`+ export type ForInOrOfStatement = ForInStatement \| ForOfStatement;`
	`1712`	`+`
`1711`	`1713`	`export interface ForInStatement extends IterationStatement {`
`1712`	`1714`	`kind: SyntaxKind.ForInStatement;`
`1713`	`1715`	`initializer: ForInitializer;`