From dae34875b44895157c8a86b5d075a5f1bd08856f Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Sep 2014 17:38:02 -0700 Subject: [PATCH] Minor CR feedback addressed. --- src/compiler/checker.ts | 6 +++--- src/compiler/emitter.ts | 10 +++++----- src/compiler/parser.ts | 12 ++++++------ src/compiler/types.ts | 4 ++-- src/harness/typeWriter.ts | 4 ++-- src/services/services.ts | 29 +++++++++++++++-------------- 6 files changed, 33 insertions(+), 32 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 80778789e7b..04ab6d4bc6b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -5815,7 +5815,7 @@ module ts { }); } - function checkLabelledStatement(node: LabelledStatement) { + function checkLabelledStatement(node: LabeledStatement) { checkSourceElement(node.statement); } @@ -6378,8 +6378,8 @@ module ts { return checkWithStatement(node); case SyntaxKind.SwitchStatement: return checkSwitchStatement(node); - case SyntaxKind.LabelledStatement: - return checkLabelledStatement(node); + case SyntaxKind.LabeledStatement: + return checkLabelledStatement(node); case SyntaxKind.ThrowStatement: return checkThrowStatement(node); case SyntaxKind.TryStatement: diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 7634e6a778c..7494b8f2b06 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -781,8 +781,8 @@ module ts { case SyntaxKind.ContinueStatement: case SyntaxKind.ExportAssignment: return false; - case SyntaxKind.LabelledStatement: - return (node.parent).label === node; + case SyntaxKind.LabeledStatement: + return (node.parent).label === node; case SyntaxKind.CatchBlock: return (node.parent).variable === node; } @@ -1200,7 +1200,7 @@ module ts { write(";"); } - function emitLabelledStatement(node: LabelledStatement) { + function emitLabelledStatement(node: LabeledStatement) { emit(node.label); write(": "); emit(node.statement); @@ -2080,8 +2080,8 @@ module ts { case SyntaxKind.CaseClause: case SyntaxKind.DefaultClause: return emitCaseOrDefaultClause(node); - case SyntaxKind.LabelledStatement: - return emitLabelledStatement(node); + case SyntaxKind.LabeledStatement: + return emitLabelledStatement(node); case SyntaxKind.ThrowStatement: return emitThrowStatement(node); case SyntaxKind.TryStatement: diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index a89152e043c..d50da53b22b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -305,9 +305,9 @@ module ts { case SyntaxKind.DefaultClause: return child((node).expression) || children((node).statements); - case SyntaxKind.LabelledStatement: - return child((node).label) || - child((node).statement); + case SyntaxKind.LabeledStatement: + return child((node).label) || + child((node).statement); case SyntaxKind.ThrowStatement: return child((node).expression); case SyntaxKind.TryStatement: @@ -371,7 +371,7 @@ module ts { case SyntaxKind.SwitchStatement: case SyntaxKind.CaseClause: case SyntaxKind.DefaultClause: - case SyntaxKind.LabelledStatement: + case SyntaxKind.LabeledStatement: case SyntaxKind.TryStatement: case SyntaxKind.TryBlock: case SyntaxKind.CatchBlock: @@ -2799,8 +2799,8 @@ module ts { return isIdentifier() && lookAhead(() => nextToken() === SyntaxKind.ColonToken); } - function parseLabelledStatement(): LabelledStatement { - var node = createNode(SyntaxKind.LabelledStatement); + function parseLabelledStatement(): LabeledStatement { + var node = createNode(SyntaxKind.LabeledStatement); node.label = parseIdentifier(); parseExpected(SyntaxKind.ColonToken); diff --git a/src/compiler/types.ts b/src/compiler/types.ts index fbd5d8b8662..aa4b149a41a 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -183,7 +183,7 @@ module ts { SwitchStatement, CaseClause, DefaultClause, - LabelledStatement, + LabeledStatement, ThrowStatement, TryStatement, TryBlock, @@ -459,7 +459,7 @@ module ts { statements: NodeArray; } - export interface LabelledStatement extends Statement { + export interface LabeledStatement extends Statement { label: Identifier; statement: Statement; } diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts index a3b23d10f14..0f88d9f0b1e 100644 --- a/src/harness/typeWriter.ts +++ b/src/harness/typeWriter.ts @@ -67,8 +67,8 @@ class TypeWriterWalker { case ts.SyntaxKind.ContinueStatement: case ts.SyntaxKind.BreakStatement: return (parent).label === identifier; - case ts.SyntaxKind.LabelledStatement: - return (parent).label === identifier; + case ts.SyntaxKind.LabeledStatement: + return (parent).label === identifier; } return false; } diff --git a/src/services/services.ts b/src/services/services.ts index 00be1a75237..92da2d095b9 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1276,8 +1276,8 @@ module ts { /// Helpers function getTargetLabel(referenceNode: Node, labelName: string): Identifier { while (referenceNode) { - if (referenceNode.kind === SyntaxKind.LabelledStatement && (referenceNode).label.text === labelName) { - return (referenceNode).label; + if (referenceNode.kind === SyntaxKind.LabeledStatement && (referenceNode).label.text === labelName) { + return (referenceNode).label; } referenceNode = referenceNode.parent; } @@ -1292,17 +1292,17 @@ module ts { function isLabelOfLabeledStatement(node: Node): boolean { return node.kind === SyntaxKind.Identifier && - node.parent.kind === SyntaxKind.LabelledStatement && - (node.parent).label === node; + node.parent.kind === SyntaxKind.LabeledStatement && + (node.parent).label === node; } /** * Whether or not a 'node' is preceded by a label of the given string. * Note: 'node' cannot be a SourceFile. */ - function isLabelledBy(node: Node, labelName: string) { - for (var owner = node.parent; owner.kind === SyntaxKind.LabelledStatement; owner = owner.parent) { - if ((owner).label.text === labelName) { + function isLabeledBy(node: Node, labelName: string) { + for (var owner = node.parent; owner.kind === SyntaxKind.LabeledStatement; owner = owner.parent) { + if ((owner).label.text === labelName) { return true; } } @@ -2372,13 +2372,13 @@ module ts { case SyntaxKind.WhileStatement: // The iteration statement is the owner if the break/continue statement is either unlabeled, // or if the break/continue statement's label corresponds to one of the loop's labels. - if (!breakOrContinueStatement.label || isLabelledBy(owner, breakOrContinueStatement.label.text)) { + if (!breakOrContinueStatement.label || isLabeledBy(owner, breakOrContinueStatement.label.text)) { return getLoopBreakContinueOccurrences(owner) } break; case SyntaxKind.SwitchStatement: // A switch statement can only be the owner of an break statement. - if (breakOrContinueStatement.kind === SyntaxKind.BreakStatement && (!breakOrContinueStatement.label || isLabelledBy(owner, breakOrContinueStatement.label.text))) { + if (breakOrContinueStatement.kind === SyntaxKind.BreakStatement && (!breakOrContinueStatement.label || isLabeledBy(owner, breakOrContinueStatement.label.text))) { return getSwitchCaseDefaultOccurrences(owner); } break; @@ -2398,7 +2398,10 @@ module ts { breakSearchType: BreakContinueSearchType, continueSearchType: BreakContinueSearchType, keywordAccumulator: Node[]): void { - (function aggregate(node: Node) { + + return aggregate(startPoint); + + function aggregate(node: Node): void { // Remember the statuses of the flags before diving into the next node. var prevBreakSearchType = breakSearchType; var prevContinueSearchType = continueSearchType; @@ -2432,9 +2435,7 @@ module ts { // Restore the last state. breakSearchType = prevBreakSearchType; continueSearchType = prevContinueSearchType; - })(startPoint); - - return; + }; } // Note: 'statement' must be a descendant of 'root'. @@ -2449,7 +2450,7 @@ module ts { continueSearchType; if (statement.label && (searchType & BreakContinueSearchType.Labeled)) { - return isLabelledBy(owner, statement.label.text); + return isLabeledBy(owner, statement.label.text); } else { return !!(searchType & BreakContinueSearchType.Unlabeled);