Minor CR feedback addressed.

DanielRosenwasser · DanielRosenwasser · commit dae34875b448 · 2014-09-10T18:59:12.000-07:00
diff --git 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(<WithStatement>node);
                 case SyntaxKind.SwitchStatement:
                     return checkSwitchStatement(<SwitchStatement>node);
-                case SyntaxKind.LabelledStatement:
-                    return checkLabelledStatement(<LabelledStatement>node);
+                case SyntaxKind.LabeledStatement:
+                    return checkLabelledStatement(<LabeledStatement>node);
                 case SyntaxKind.ThrowStatement:
                     return checkThrowStatement(<ThrowStatement>node);
                 case SyntaxKind.TryStatement:
diff --git 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 (<LabelledStatement>node.parent).label === node;
+                    case SyntaxKind.LabeledStatement:
+                        return (<LabeledStatement>node.parent).label === node;
                     case SyntaxKind.CatchBlock:
                         return (<CatchBlock>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(<CaseOrDefaultClause>node);
-                    case SyntaxKind.LabelledStatement:
-                        return emitLabelledStatement(<LabelledStatement>node);
+                    case SyntaxKind.LabeledStatement:
+                        return emitLabelledStatement(<LabeledStatement>node);
                     case SyntaxKind.ThrowStatement:
                         return emitThrowStatement(<ThrowStatement>node);
                     case SyntaxKind.TryStatement:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -305,9 +305,9 @@ module ts {
             case SyntaxKind.DefaultClause:
                 return child((<CaseOrDefaultClause>node).expression) ||
                     children((<CaseOrDefaultClause>node).statements);
-            case SyntaxKind.LabelledStatement:
-                return child((<LabelledStatement>node).label) ||
-                    child((<LabelledStatement>node).statement);
+            case SyntaxKind.LabeledStatement:
+                return child((<LabeledStatement>node).label) ||
+                    child((<LabeledStatement>node).statement);
             case SyntaxKind.ThrowStatement:
                 return child((<ThrowStatement>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 = <LabelledStatement>createNode(SyntaxKind.LabelledStatement);
+        function parseLabelledStatement(): LabeledStatement {
+            var node = <LabeledStatement>createNode(SyntaxKind.LabeledStatement);
             node.label = parseIdentifier();
             parseExpected(SyntaxKind.ColonToken);
 
diff --git 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<Statement>;
     }
 
-    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
@@ -67,8 +67,8 @@ class TypeWriterWalker {
             case ts.SyntaxKind.ContinueStatement:
             case ts.SyntaxKind.BreakStatement:
                 return (<ts.BreakOrContinueStatement>parent).label === identifier;
-            case ts.SyntaxKind.LabelledStatement:
-                return (<ts.LabelledStatement>parent).label === identifier;
+            case ts.SyntaxKind.LabeledStatement:
+                return (<ts.LabeledStatement>parent).label === identifier;
         }
         return false;
     }
diff --git 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 && (<LabelledStatement>referenceNode).label.text === labelName) {
-                return (<LabelledStatement>referenceNode).label;
+            if (referenceNode.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>referenceNode).label.text === labelName) {
+                return (<LabeledStatement>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 &&
-            (<LabelledStatement>node.parent).label === node;
+            node.parent.kind === SyntaxKind.LabeledStatement &&
+            (<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 ((<LabelledStatement>owner).label.text === labelName) {
+    function isLabeledBy(node: Node, labelName: string) {
+        for (var owner = node.parent; owner.kind === SyntaxKind.LabeledStatement; owner = owner.parent) {
+            if ((<LabeledStatement>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(<IterationStatement>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(<SwitchStatement>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);

Original file line number	Diff line number	Diff line change
`@@ -67,8 +67,8 @@ class TypeWriterWalker {`
`67`	`67`	`case ts.SyntaxKind.ContinueStatement:`
`68`	`68`	`case ts.SyntaxKind.BreakStatement:`
`69`	`69`	`return (<ts.BreakOrContinueStatement>parent).label === identifier;`
`70`		`- case ts.SyntaxKind.LabelledStatement:`
`71`		`- return (<ts.LabelledStatement>parent).label === identifier;`
	`70`	`+ case ts.SyntaxKind.LabeledStatement:`
	`71`	`+ return (<ts.LabeledStatement>parent).label === identifier;`
`72`	`72`	`}`
`73`	`73`	`return false;`
`74`	`74`	`}`