diff --git a/src/services/compiler/precompile.ts b/src/services/compiler/precompile.ts
index 08a919a65b5..3396cb4f2a2 100644
--- a/src/services/compiler/precompile.ts
+++ b/src/services/compiler/precompile.ts
@@ -99,26 +99,26 @@ module TypeScript {
         var start = new Date().getTime();
         // Look for: 
         // import foo = module("foo")
-        while (token.kind() !== SyntaxKind.EndOfFileToken) {
-            if (token.kind() === SyntaxKind.ImportKeyword) {
+        while (token.kind !== SyntaxKind.EndOfFileToken) {
+            if (token.kind === SyntaxKind.ImportKeyword) {
                 var importToken = token;
                 token = scanner.scan(/*allowRegularExpression:*/ false);
 
                 if (SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) {
                     token = scanner.scan(/*allowRegularExpression:*/ false);
 
-                    if (token.kind() === SyntaxKind.EqualsToken) {
+                    if (token.kind === SyntaxKind.EqualsToken) {
                         token = scanner.scan(/*allowRegularExpression:*/ false);
 
-                        if (token.kind() === SyntaxKind.ModuleKeyword || token.kind() === SyntaxKind.RequireKeyword) {
+                        if (token.kind === SyntaxKind.ModuleKeyword || token.kind === SyntaxKind.RequireKeyword) {
                             token = scanner.scan(/*allowRegularExpression:*/ false);
 
-                            if (token.kind() === SyntaxKind.OpenParenToken) {
+                            if (token.kind === SyntaxKind.OpenParenToken) {
                                 token = scanner.scan(/*allowRegularExpression:*/ false);
 
                                 lineMap.fillLineAndCharacterFromPosition(TypeScript.start(importToken, text), lineChar);
 
-                                if (token.kind() === SyntaxKind.StringLiteral) {
+                                if (token.kind === SyntaxKind.StringLiteral) {
                                     var ref = {
                                         line: lineChar.line,
                                         character: lineChar.character,
diff --git a/src/services/formatting/formatter.ts b/src/services/formatting/formatter.ts
index a98d969c059..92417168eac 100644
--- a/src/services/formatting/formatter.ts
+++ b/src/services/formatting/formatter.ts
@@ -78,7 +78,7 @@ module TypeScript.Services.Formatting {
             }
 
             // Push the token
-            var currentTokenSpan = new TokenSpan(token.kind(), position, width(token));
+            var currentTokenSpan = new TokenSpan(token.kind, position, width(token));
             if (!this.parent().hasSkippedOrMissingTokenChild()) {
                 if (this.previousTokenSpan) {
                     // Note that formatPair calls TrimWhitespaceInLineRange in between the 2 tokens
diff --git a/src/services/formatting/formattingManager.ts b/src/services/formatting/formattingManager.ts
index 727c97cce30..b83281fb9ec 100644
--- a/src/services/formatting/formattingManager.ts
+++ b/src/services/formatting/formattingManager.ts
@@ -42,12 +42,12 @@ module TypeScript.Services.Formatting {
             var sourceUnit = this.syntaxTree.sourceUnit();
             var semicolonPositionedToken = findToken(sourceUnit, caretPosition - 1);
 
-            if (semicolonPositionedToken.kind() === SyntaxKind.SemicolonToken) {
+            if (semicolonPositionedToken.kind === SyntaxKind.SemicolonToken) {
                 // Find the outer most parent that this semicolon terminates
                 var current: ISyntaxElement = semicolonPositionedToken;
                 while (current.parent !== null &&
                     end(current.parent) === end(semicolonPositionedToken) &&
-                    current.parent.kind() !== SyntaxKind.List) {
+                    current.parent.kind !== SyntaxKind.List) {
                     current = current.parent;
                 }
 
@@ -65,12 +65,12 @@ module TypeScript.Services.Formatting {
             var sourceUnit = this.syntaxTree.sourceUnit();
             var closeBracePositionedToken = findToken(sourceUnit, caretPosition - 1);
 
-            if (closeBracePositionedToken.kind() === SyntaxKind.CloseBraceToken) {
+            if (closeBracePositionedToken.kind === SyntaxKind.CloseBraceToken) {
                 // Find the outer most parent that this closing brace terminates
                 var current: ISyntaxElement = closeBracePositionedToken;
                 while (current.parent !== null &&
                     end(current.parent) === end(closeBracePositionedToken) &&
-                    current.parent.kind() !== SyntaxKind.List) {
+                    current.parent.kind !== SyntaxKind.List) {
                     current = current.parent;
                 }
 
diff --git a/src/services/formatting/indentationNodeContext.ts b/src/services/formatting/indentationNodeContext.ts
index 398d4998eed..7aa10d2f9b9 100644
--- a/src/services/formatting/indentationNodeContext.ts
+++ b/src/services/formatting/indentationNodeContext.ts
@@ -66,7 +66,7 @@ module TypeScript.Services.Formatting {
         }
 
         public kind(): SyntaxKind {
-            return this._node.kind();
+            return this._node.kind;
         }
 
         public hasSkippedOrMissingTokenChild(): boolean {
diff --git a/src/services/formatting/indentationTrackingWalker.ts b/src/services/formatting/indentationTrackingWalker.ts
index d02f2f50825..9ed998858c5 100644
--- a/src/services/formatting/indentationTrackingWalker.ts
+++ b/src/services/formatting/indentationTrackingWalker.ts
@@ -103,7 +103,7 @@ module TypeScript.Services.Formatting {
                 if (isToken(element)) {
                     this.visitToken(<ISyntaxToken>element);
                 }
-                else if (element.kind() === SyntaxKind.List) {
+                else if (element.kind === SyntaxKind.List) {
                     for (var i = 0, n = childCount(element); i < n; i++) {
                         this.walk(childAt(element, i));
                     }
@@ -148,9 +148,9 @@ module TypeScript.Services.Formatting {
             // }
             // Also in a do-while statement, the while should be indented like the parent.
             if (firstToken(this._parent.node()) === token ||
-                token.kind() === SyntaxKind.OpenBraceToken || token.kind() === SyntaxKind.CloseBraceToken ||
-                token.kind() === SyntaxKind.OpenBracketToken || token.kind() === SyntaxKind.CloseBracketToken ||
-                (token.kind() === SyntaxKind.WhileKeyword && this._parent.node().kind() == SyntaxKind.DoStatement)) {
+                token.kind === SyntaxKind.OpenBraceToken || token.kind === SyntaxKind.CloseBraceToken ||
+                token.kind === SyntaxKind.OpenBracketToken || token.kind === SyntaxKind.CloseBracketToken ||
+                (token.kind === SyntaxKind.WhileKeyword && this._parent.node().kind == SyntaxKind.DoStatement)) {
                 return this._parent.indentationAmount();
             }
 
@@ -161,7 +161,7 @@ module TypeScript.Services.Formatting {
             // If this is token terminating an indentation scope, leading comments should be indented to follow the children 
             // indentation level and not the node
 
-            if (token.kind() === SyntaxKind.CloseBraceToken || token.kind() === SyntaxKind.CloseBracketToken) {
+            if (token.kind === SyntaxKind.CloseBraceToken || token.kind === SyntaxKind.CloseBracketToken) {
                 return (this._parent.indentationAmount() + this._parent.childIndentationAmountDelta());
             }
             return this._parent.indentationAmount();
@@ -213,7 +213,7 @@ module TypeScript.Services.Formatting {
             var indentationAmountDelta: number;
             var parentNode = parent.node();
 
-            switch (node.kind()) {
+            switch (node.kind) {
                 default:
                     // General case
                     // This node should follow the child indentation set by its parent
diff --git a/src/services/formatting/multipleTokenIndenter.ts b/src/services/formatting/multipleTokenIndenter.ts
index 23181571427..9297db96635 100644
--- a/src/services/formatting/multipleTokenIndenter.ts
+++ b/src/services/formatting/multipleTokenIndenter.ts
@@ -119,7 +119,7 @@ module TypeScript.Services.Formatting {
 
             }
 
-            if (token.kind() !== SyntaxKind.EndOfFileToken && indentNextTokenOrTrivia) {
+            if (token.kind !== SyntaxKind.EndOfFileToken && indentNextTokenOrTrivia) {
                 // If the last trivia item was a new line, or no trivia items were encounterd record the 
                 // indentation edit at the token position
                 if (indentationString.length > 0) {
diff --git a/src/services/syntax/SyntaxGenerator.js b/src/services/syntax/SyntaxGenerator.js
index 1368f22e189..0da69eec942 100644
--- a/src/services/syntax/SyntaxGenerator.js
+++ b/src/services/syntax/SyntaxGenerator.js
@@ -1982,7 +1982,7 @@ function generateConstructorFunction(definition) {
         result += ";\r\n";
     }
     result += "    };\r\n";
-    result += "    " + definition.name + ".prototype.kind = function() { return SyntaxKind." + getNameWithoutSuffix(definition) + "; }\r\n";
+    result += "    " + definition.name + ".prototype.kind = SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
     return result;
 }
 function generateSyntaxInterfaces() {
@@ -2154,16 +2154,28 @@ function max(array, func) {
     }
     return max;
 }
+function generateUtilities() {
+    var result = "";
+    result += "        var fixedWidthArray = [";
+    for (var i = 0; i <= TypeScript.SyntaxKind.LastFixedWidth; i++) {
+        if (i) {
+            result += ", ";
+        }
+        if (i < TypeScript.SyntaxKind.FirstFixedWidth) {
+            result += "0";
+        }
+        else {
+            result += TypeScript.SyntaxFacts.getText(i).length;
+        }
+    }
+    result += "];\r\n";
+    result += "        function fixedWidthTokenLength(kind: SyntaxKind) {\r\n";
+    result += "            return fixedWidthArray[kind];\r\n";
+    result += "        }\r\n";
+    return result;
+}
 function generateScannerUtilities() {
     var result = "///<reference path='references.ts' />\r\n" + "\r\n" + "module TypeScript {\r\n" + "    export module ScannerUtilities {\r\n";
-    result += "        export function fixedWidthTokenLength(kind: SyntaxKind) {\r\n";
-    result += "            switch (kind) {\r\n";
-    for (var k = TypeScript.SyntaxKind.FirstFixedWidth; k <= TypeScript.SyntaxKind.LastFixedWidth; k++) {
-        result += "                case SyntaxKind." + syntaxKindName(k) + ": return " + TypeScript.SyntaxFacts.getText(k).length + ";\r\n";
-    }
-    result += "                default: throw new Error();\r\n";
-    result += "            }\r\n";
-    result += "        }\r\n\r\n";
     var i;
     var keywords = [];
     for (i = TypeScript.SyntaxKind.FirstKeyword; i <= TypeScript.SyntaxKind.LastKeyword; i++) {
@@ -2202,7 +2214,7 @@ function generateVisitor() {
     result += "module TypeScript {\r\n";
     result += "    export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {\r\n";
     result += "        if (element === undefined) { return undefined; }\r\n";
-    result += "        switch (element.kind()) {\r\n";
+    result += "        switch (element.kind) {\r\n";
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
         result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ": ";
@@ -2240,31 +2252,38 @@ function generateServicesUtilities() {
     result += "];\r\n\r\n";
     result += "    export function childCount(element: ISyntaxElement): number {\r\n";
     result += "        if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }\r\n";
-    result += "        return childCountArray[element.kind()];\r\n";
+    result += "        return childCountArray[element.kind];\r\n";
     result += "    }\r\n\r\n";
+    result += "    var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [\r\n        ";
+    for (var i = 0; i < TypeScript.SyntaxKind.FirstNode; i++) {
+        if (i) {
+            result += ", ";
+        }
+        result += "undefined";
+    }
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
-        result += "    function " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(node: " + definition.name + ", index: number): ISyntaxElement {\r\n";
+        result += ",\r\n";
+        result += "        (node: " + definition.name + ", index: number): ISyntaxElement => {\r\n";
         if (definition.children.length) {
-            result += "        switch (index) {\r\n";
+            result += "            switch (index) {\r\n";
             for (var j = 0; j < definition.children.length; j++) {
-                result += "            case " + j + ": return node." + definition.children[j].name + ";\r\n";
+                result += "                case " + j + ": return node." + definition.children[j].name + ";\r\n";
             }
-            result += "        }\r\n";
+            result += "            }\r\n";
         }
         else {
-            result += "        throw Errors.invalidOperation();\r\n";
+            result += "            throw Errors.invalidOperation();\r\n";
         }
-        result += "    }\r\n";
+        result += "        }";
     }
+    result += "\r\n    ];\r\n";
     result += "    export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {\r\n";
     result += "        if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }\r\n";
-    result += "        switch (element.kind()) {\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ": return " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(<" + definition.name + ">element, index);\r\n";
-    }
-    result += "        }\r\n";
+    result += "        return childAtArray[element.kind](element, index);\r\n";
+    result += "    }\r\n\r\n";
+    result += "    export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {\r\n";
+    result += "        return childAtArray[element.kind];\r\n";
     result += "    }\r\n";
     result += "}";
     return result;
@@ -2275,9 +2294,11 @@ var walker = generateWalker();
 var scannerUtilities = generateScannerUtilities();
 var visitor = generateVisitor();
 var servicesUtilities = generateServicesUtilities();
+var utilities = generateUtilities();
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterfaces.generated.ts", syntaxInterfaces, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker.generated.ts", walker, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\utilities.generated.ts", utilities, false);
diff --git a/src/services/syntax/incrementalParser.ts b/src/services/syntax/incrementalParser.ts
index 306d21be319..c0d1d4aa0ed 100644
--- a/src/services/syntax/incrementalParser.ts
+++ b/src/services/syntax/incrementalParser.ts
@@ -235,7 +235,20 @@ module TypeScript.IncrementalParser {
                 !_oldSourceUnitCursor.isFinished();
         }
 
-        function updateTokens(nodeOrToken: ISyntaxNodeOrToken): void {
+        function updateTokenPosition(token: ISyntaxToken): void {
+            // If we got a node or token, and we're past the range of edited text, then walk its
+            // constituent tokens, making sure all their positions are correct.  We don't need to
+            // do this for the tokens before the edited range (since their positions couldn't have 
+            // been affected by the edit), and we don't need to do this for the tokens in the 
+            // edited range, as their positions will be correct when the underlying parser source 
+            // creates them.
+
+            if (isPastChangeRange()) {
+                token.setFullStart(absolutePosition());
+            }
+        }
+
+        function updateNodePosition(node: ISyntaxNode): void {
             // If we got a node or token, and we're past the range of edited text, then walk its
             // constituent tokens, making sure all their positions are correct.  We don't need to
             // do this for the tokens before the edited range (since their positions couldn't have 
@@ -246,18 +259,13 @@ module TypeScript.IncrementalParser {
             if (isPastChangeRange()) {
                 var position = absolutePosition();
 
-                if (isToken(nodeOrToken)) {
-                    (<ISyntaxToken>nodeOrToken).setFullStart(position);
-                }
-                else {
-                    var tokens = getTokens(<ISyntaxNode>nodeOrToken);
+                var tokens = getTokens(node);
 
-                    for (var i = 0, n = tokens.length; i < n; i++) {
-                        var token = tokens[i];
-                        token.setFullStart(position);
+                for (var i = 0, n = tokens.length; i < n; i++) {
+                    var token = tokens[i];
+                    token.setFullStart(position);
 
-                        position += token.fullWidth();
-                    }
+                    position += token.fullWidth();
                 }
             }
         }
@@ -284,7 +292,7 @@ module TypeScript.IncrementalParser {
                 var node = tryGetNodeFromOldSourceUnit();
                 if (node) {
                     // Make sure the positions for the tokens in this node are correct.
-                    updateTokens(node);
+                    updateNodePosition(node);
                     return node;
                 }
             }
@@ -298,7 +306,7 @@ module TypeScript.IncrementalParser {
                 var token = tryGetTokenFromOldSourceUnit();
                 if (token) {
                     // Make sure the token's position/text is correct.
-                    updateTokens(token);
+                    updateTokenPosition(token);
                     return token;
                 }
             }
diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts
index 6f35b45428b..eb23de608a6 100644
--- a/src/services/syntax/parser.ts
+++ b/src/services/syntax/parser.ts
@@ -290,7 +290,7 @@ module TypeScript.Parser {
         //we should keep it simple so that it can be inlined.
         function eatToken(kind: SyntaxKind): ISyntaxToken {
             var token = currentToken();
-            if (token.kind() === kind) {
+            if (token.kind === kind) {
                 return consumeToken(token);
             }
 
@@ -301,7 +301,7 @@ module TypeScript.Parser {
         // Eats the token if it is there.  Otherwise does nothing.  Will not report errors.
         function tryEatToken(kind: SyntaxKind): ISyntaxToken {
             var _currentToken = currentToken();
-            if (_currentToken.kind() === kind) {
+            if (_currentToken.kind === kind) {
                 return consumeToken(_currentToken);
             }
 
@@ -313,7 +313,7 @@ module TypeScript.Parser {
         // on the state of the parser.  For example, 'yield' is an identifier *unless* the parser 
         // is in strict mode.
         function isIdentifier(token: ISyntaxToken): boolean {
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
 
             if (tokenKind === SyntaxKind.IdentifierName) {
                 return true;
@@ -342,7 +342,7 @@ module TypeScript.Parser {
             var token = currentToken();
 
             // If we have an identifier name, then consume and return it.
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
             if (tokenKind === SyntaxKind.IdentifierName) {
                 return consumeToken(token);
             }
@@ -368,7 +368,7 @@ module TypeScript.Parser {
             if (isIdentifier(token)) {
                 consumeToken(token);
 
-                if (token.kind() === SyntaxKind.IdentifierName) {
+                if (token.kind === SyntaxKind.IdentifierName) {
                     return token;
                 }
 
@@ -398,7 +398,7 @@ module TypeScript.Parser {
             var token = currentToken();
 
             // An automatic semicolon is always allowed if we're at the end of the file.
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
             if (tokenKind === SyntaxKind.EndOfFileToken) {
                 return true;
             }
@@ -423,7 +423,7 @@ module TypeScript.Parser {
         function canEatExplicitOrAutomaticSemicolon(allowWithoutNewline: boolean): boolean {
             var token = currentToken();
 
-            if (token.kind() === SyntaxKind.SemicolonToken) {
+            if (token.kind === SyntaxKind.SemicolonToken) {
                 return true;
             }
 
@@ -434,7 +434,7 @@ module TypeScript.Parser {
             var token = currentToken();
 
             // If we see a semicolon, then we can definitely eat it.
-            if (token.kind() === SyntaxKind.SemicolonToken) {
+            if (token.kind === SyntaxKind.SemicolonToken) {
                 return consumeToken(token);
             }
 
@@ -474,9 +474,9 @@ module TypeScript.Parser {
                     // They wanted an identifier.
 
                     // If the user supplied a keyword, give them a specialized message.
-                    if (actual && SyntaxFacts.isAnyKeyword(actual.kind())) {
+                    if (actual && SyntaxFacts.isAnyKeyword(actual.kind)) {
                         diagnosticCode = DiagnosticCode.Identifier_expected_0_is_a_keyword;
-                        args = [SyntaxFacts.getText(actual.kind())];
+                        args = [SyntaxFacts.getText(actual.kind)];
                     }
                     else {
                         // Otherwise just report that an identifier was expected.
@@ -608,7 +608,7 @@ module TypeScript.Parser {
         }
 
         function addSkippedTokensBeforeToken(token: ISyntaxToken, skippedTokens: ISyntaxToken[]): ISyntaxToken {
-            // Debug.assert(token.fullWidth() > 0 || token.kind() === SyntaxKind.EndOfFileToken);
+            // Debug.assert(token.fullWidth() > 0 || token.kind === SyntaxKind.EndOfFileToken);
             // Debug.assert(skippedTokens.length > 0);
 
             var leadingTrivia: ISyntaxTrivia[] = [];
@@ -711,12 +711,16 @@ module TypeScript.Parser {
             return sourceUnit;
         }
 
+        function isDirectivePrologueElement(node: ISyntaxNodeOrToken): boolean {
+            return node.kind === SyntaxKind.ExpressionStatement &&
+                (<ExpressionStatementSyntax>node).expression.kind === SyntaxKind.StringLiteral;
+        }
+
         function updateStrictModeState(items: any[]): void {
             if (!isInStrictMode) {
                 // Check if all the items are directive prologue elements.
-                for (var i = 0; i < items.length; i++) {
-                    var item = items[i];
-                    if (!SyntaxFacts.isDirectivePrologueElement(item)) {
+                for (var i = 0, n = items.length; i < n; i++) {
+                    if (!isDirectivePrologueElement(items[i])) {
                         return;
                     }
                 }
@@ -748,7 +752,7 @@ module TypeScript.Parser {
             if (_modifierCount) {
                 // if we have modifiers, then these are definitely TS constructs and we can 
                 // immediately start parsing them.
-                switch (peekToken(_modifierCount).kind()) {
+                switch (peekToken(_modifierCount).kind) {
                     case SyntaxKind.ImportKeyword: return parseImportDeclaration();
                     case SyntaxKind.ModuleKeyword: return parseModuleDeclaration();
                     case SyntaxKind.InterfaceKeyword: return parseInterfaceDeclaration();
@@ -764,10 +768,10 @@ module TypeScript.Parser {
             // consuming these, we only parse them out if we can see enough context to 'prove' that
             // they really do start the module element
             var nextToken = peekToken(1);
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
             switch (currentTokenKind) {
                 case SyntaxKind.ModuleKeyword:
-                    if (isIdentifier(nextToken) || nextToken.kind() === SyntaxKind.StringLiteral) {
+                    if (isIdentifier(nextToken) || nextToken.kind === SyntaxKind.StringLiteral) {
                         return parseModuleDeclaration();
                     }
                     break;
@@ -799,7 +803,7 @@ module TypeScript.Parser {
                 case SyntaxKind.ExportKeyword:
                     // 'export' could be a modifier on a statement (like export var ...).  So we 
                     // only want to parse out an export assignment here if we actually see the equals.
-                    if (nextToken.kind() === SyntaxKind.EqualsToken) {
+                    if (nextToken.kind === SyntaxKind.EqualsToken) {
                         return parseExportAssignment();
                     }
                     break;
@@ -823,8 +827,8 @@ module TypeScript.Parser {
         }
 
         function isExternalModuleReference(): boolean {
-            return currentToken().kind() === SyntaxKind.RequireKeyword &&
-                   peekToken(1).kind() === SyntaxKind.OpenParenToken;
+            return currentToken().kind === SyntaxKind.RequireKeyword &&
+                   peekToken(1).kind === SyntaxKind.OpenParenToken;
         }
 
         function parseExternalModuleReference(): ExternalModuleReferenceSyntax {
@@ -838,7 +842,7 @@ module TypeScript.Parser {
 
         function tryParseTypeArgumentList(inExpression: boolean): TypeArgumentListSyntax {
             var _currentToken = currentToken();
-            if (_currentToken.kind() !== SyntaxKind.LessThanToken) {
+            if (_currentToken.kind !== SyntaxKind.LessThanToken) {
                 return undefined;
             }
 
@@ -871,7 +875,7 @@ module TypeScript.Parser {
             // We're in a context where '<' could be the start of a type argument list, or part
             // of an arithmetic expression.  We'll presume it's the latter unless we see the '>'
             // and a following token that guarantees that it's supposed to be a type argument list.
-            if (greaterThanToken.fullWidth() === 0 || !canFollowTypeArgumentListInExpression(currentToken().kind())) {
+            if (greaterThanToken.fullWidth() === 0 || !canFollowTypeArgumentListInExpression(currentToken().kind)) {
                 rewind(rewindPoint);
                 releaseRewindPoint(rewindPoint);
                 return undefined;
@@ -943,7 +947,7 @@ module TypeScript.Parser {
             // the code would be implicitly: "name.keyword; identifierNameOrKeyword".  
             // In the first case though, ASI will not take effect because there is not a
             // line terminator after the keyword.
-            if (SyntaxFacts.isAnyKeyword(_currentToken.kind()) &&
+            if (SyntaxFacts.isAnyKeyword(_currentToken.kind) &&
                 previousTokenHasTrailingNewLine(_currentToken)) {
 
                 var token1 = peekToken(1);
@@ -967,7 +971,7 @@ module TypeScript.Parser {
             // Call eatIdentifierName to convert the token to an identifier if it is as keyword.
             var current: INameSyntax = eatIdentifierToken();
 
-            while (shouldContinue && currentToken().kind() === SyntaxKind.DotToken) {
+            while (shouldContinue && currentToken().kind === SyntaxKind.DotToken) {
                 var dotToken = consumeToken(currentToken());
                 var identifierName = eatRightSideOfName(allowIdentifierNames);
 
@@ -997,7 +1001,7 @@ module TypeScript.Parser {
 
         function isEnumElement(inErrorRecovery: boolean): boolean {
             var node = currentNode();
-            if (node && node.kind() === SyntaxKind.EnumElement) {
+            if (node && node.kind === SyntaxKind.EnumElement) {
                 return true;
             }
 
@@ -1010,7 +1014,7 @@ module TypeScript.Parser {
 
         function tryParseEnumElement(inErrorRecovery: boolean): EnumElementSyntax {
             var node = currentNode();
-            if (node && node.kind() === SyntaxKind.EnumElement) {
+            if (node && node.kind === SyntaxKind.EnumElement) {
                 consumeNode(node);
                 return <EnumElementSyntax>node;
             }
@@ -1037,13 +1041,13 @@ module TypeScript.Parser {
         }
 
         function isModifier(token: ISyntaxToken, index: number): boolean {
-            if (isModifierKind(token.kind())) {
+            if (isModifierKind(token.kind)) {
                 // These are modifiers only if we see an actual keyword, identifier, string literal
                 // or number following.
                 // Note: we also allow [ for error conditions.  
                 // [   is for:     static [a: number]
                 var nextToken = peekToken(index + 1);
-                var nextTokenKind = nextToken.kind();
+                var nextTokenKind = nextToken.kind;
 
                 switch (nextTokenKind) {
                     case SyntaxKind.IdentifierName:
@@ -1121,7 +1125,7 @@ module TypeScript.Parser {
         }
 
         function isAccessor(modifierCount: number, inErrorRecovery: boolean): boolean {
-            var tokenKind = peekToken(modifierCount).kind();
+            var tokenKind = peekToken(modifierCount).kind;
             if (tokenKind !== SyntaxKind.GetKeyword &&
                 tokenKind !== SyntaxKind.SetKeyword) {
                 return false;
@@ -1133,7 +1137,7 @@ module TypeScript.Parser {
         function parseAccessor(checkForStrictMode: boolean): ISyntaxNode {
             var modifiers = parseModifiers();
             var _currenToken = currentToken();
-            var tokenKind = _currenToken.kind();
+            var tokenKind = _currenToken.kind;
 
             if (tokenKind === SyntaxKind.GetKeyword) {
                 return parseGetMemberAccessorDeclaration(modifiers, _currenToken, checkForStrictMode);
@@ -1208,7 +1212,7 @@ module TypeScript.Parser {
             // assume this is a constructor.  That means, if a user writes "public constructor;"
             // it won't be viewed as a member.  As a workaround, they can simply write:
             //      public 'constructor';
-            return peekToken(modifierCount).kind() === SyntaxKind.ConstructorKeyword;
+            return peekToken(modifierCount).kind === SyntaxKind.ConstructorKeyword;
         }
 
         function parseConstructorDeclaration(): ConstructorDeclarationSyntax {
@@ -1264,9 +1268,9 @@ module TypeScript.Parser {
             //      public }
             //      public <eof>
             //      public <newline>
-            if (SyntaxFacts.isAnyKeyword(peekToken(index).kind())) {
+            if (SyntaxFacts.isAnyKeyword(peekToken(index).kind)) {
                 var nextToken = peekToken(index + 1);
-                switch (nextToken.kind()) {
+                switch (nextToken.kind) {
                     case SyntaxKind.SemicolonToken:
                     case SyntaxKind.EqualsToken:
                     case SyntaxKind.ColonToken:
@@ -1305,7 +1309,7 @@ module TypeScript.Parser {
         function tryAddUnexpectedEqualsGreaterThanToken(callSignature: CallSignatureSyntax): boolean {
             var token0 = currentToken();
 
-            var hasEqualsGreaterThanToken = token0.kind() === SyntaxKind.EqualsGreaterThanToken;
+            var hasEqualsGreaterThanToken = token0.kind === SyntaxKind.EqualsGreaterThanToken;
             if (hasEqualsGreaterThanToken) {
                 // We can only do this if the call signature actually contains a final token that we 
                 // could add the => to.
@@ -1331,7 +1335,7 @@ module TypeScript.Parser {
         }
 
         function isFunctionDeclaration(modifierCount: number): boolean {
-            return peekToken(modifierCount).kind() === SyntaxKind.FunctionKeyword;
+            return peekToken(modifierCount).kind === SyntaxKind.FunctionKeyword;
         }
 
         function parseFunctionDeclaration(): FunctionDeclarationSyntax {
@@ -1365,7 +1369,7 @@ module TypeScript.Parser {
             var moduleName: INameSyntax = undefined;
             var stringLiteral: ISyntaxToken = undefined;
 
-            if (currentToken().kind() === SyntaxKind.StringLiteral) {
+            if (currentToken().kind === SyntaxKind.StringLiteral) {
                 stringLiteral = eatToken(SyntaxKind.StringLiteral);
             }
             else {
@@ -1484,12 +1488,12 @@ module TypeScript.Parser {
         }
 
         function isCallSignature(peekIndex: number): boolean {
-            var tokenKind = peekToken(peekIndex).kind();
+            var tokenKind = peekToken(peekIndex).kind;
             return tokenKind === SyntaxKind.OpenParenToken || tokenKind === SyntaxKind.LessThanToken;
         }
 
         function isConstructSignature(): boolean {
-            if (currentToken().kind() !== SyntaxKind.NewKeyword) {
+            if (currentToken().kind !== SyntaxKind.NewKeyword) {
                 return false;
             }
 
@@ -1497,7 +1501,7 @@ module TypeScript.Parser {
         }
 
         function isIndexSignature(peekIndex: number): boolean {
-            return peekToken(peekIndex).kind() === SyntaxKind.OpenBracketToken;
+            return peekToken(peekIndex).kind === SyntaxKind.OpenBracketToken;
         }
 
         function isMethodSignature(inErrorRecovery: boolean): boolean {
@@ -1508,7 +1512,7 @@ module TypeScript.Parser {
                 }
 
                 // id?(
-                if (peekToken(1).kind() === SyntaxKind.QuestionToken &&
+                if (peekToken(1).kind === SyntaxKind.QuestionToken &&
                     isCallSignature(2)) {
                     return true;
                 }
@@ -1546,12 +1550,12 @@ module TypeScript.Parser {
         }
 
         function isHeritageClause(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             return tokenKind === SyntaxKind.ExtendsKeyword || tokenKind === SyntaxKind.ImplementsKeyword;
         }
 
         function isNotHeritageClauseTypeName(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.ImplementsKeyword ||
                 tokenKind === SyntaxKind.ExtendsKeyword) {
 
@@ -1573,7 +1577,7 @@ module TypeScript.Parser {
 
         function tryParseHeritageClause(): HeritageClauseSyntax {
             var extendsOrImplementsKeyword = currentToken();
-            var tokenKind = extendsOrImplementsKeyword.kind();
+            var tokenKind = extendsOrImplementsKeyword.kind;
             if (tokenKind !== SyntaxKind.ExtendsKeyword && tokenKind !== SyntaxKind.ImplementsKeyword) {
                 return undefined;
             }
@@ -1590,7 +1594,7 @@ module TypeScript.Parser {
         function isInterfaceEnumClassModuleImportOrExport(modifierCount: number, _currentToken?: ISyntaxToken): boolean {
             if (modifierCount) {
                 // Any of these keywords following a modifier is definitely a TS construct.
-                switch (peekToken(modifierCount).kind()) {
+                switch (peekToken(modifierCount).kind) {
                     case SyntaxKind.ImportKeyword: 
                     case SyntaxKind.ModuleKeyword: 
                     case SyntaxKind.InterfaceKeyword: 
@@ -1609,9 +1613,9 @@ module TypeScript.Parser {
             // make sure it really is the start of a module element.
             var nextToken = peekToken(1);
 
-            switch (_currentToken.kind()) {
+            switch (_currentToken.kind) {
                 case SyntaxKind.ModuleKeyword:
-                    return isIdentifier(nextToken) || nextToken.kind() === SyntaxKind.StringLiteral;
+                    return isIdentifier(nextToken) || nextToken.kind === SyntaxKind.StringLiteral;
 
                 case SyntaxKind.ImportKeyword:
                 case SyntaxKind.ClassKeyword:
@@ -1620,7 +1624,7 @@ module TypeScript.Parser {
                     return isIdentifier(nextToken);
 
                 case SyntaxKind.ExportKeyword:
-                    return nextToken.kind() === SyntaxKind.EqualsToken;
+                    return nextToken.kind === SyntaxKind.EqualsToken;
             }
 
             return false;
@@ -1632,7 +1636,7 @@ module TypeScript.Parser {
             }
 
             var _currentToken = currentToken();
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
             switch (currentTokenKind) {
                 // ERROR RECOVERY
                 case SyntaxKind.PublicKeyword:
@@ -1697,7 +1701,7 @@ module TypeScript.Parser {
             }
 
             var _currentToken = currentToken();
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
             return tryParseStatementWorker(_currentToken, currentTokenKind, modifierCount(), inErrorRecovery);
         }
 
@@ -1777,7 +1781,7 @@ module TypeScript.Parser {
         }
 
         function isLabeledStatement(currentToken: ISyntaxToken): boolean {
-            return isIdentifier(currentToken) && peekToken(1).kind() === SyntaxKind.ColonToken;
+            return isIdentifier(currentToken) && peekToken(1).kind === SyntaxKind.ColonToken;
         }
 
         function parseLabeledStatement(identifierToken: ISyntaxToken): LabeledStatementSyntax {
@@ -1794,14 +1798,14 @@ module TypeScript.Parser {
             listParsingState = savedListParsingState;
 
             var catchClause: CatchClauseSyntax = undefined;
-            if (currentToken().kind() === SyntaxKind.CatchKeyword) {
+            if (currentToken().kind === SyntaxKind.CatchKeyword) {
                 catchClause = parseCatchClause();
             }
 
             // If we don't have a catch clause, then we must have a finally clause.  Try to parse
             // one out no matter what.
             var finallyClause: FinallyClauseSyntax = undefined;
-            if (!catchClause || currentToken().kind() === SyntaxKind.FinallyKeyword) {
+            if (!catchClause || currentToken().kind === SyntaxKind.FinallyKeyword) {
                 finallyClause = parseFinallyClause();
             }
 
@@ -1849,7 +1853,7 @@ module TypeScript.Parser {
                 return false;
             }
 
-            return currentToken.kind() === SyntaxKind.SemicolonToken;
+            return currentToken.kind === SyntaxKind.SemicolonToken;
         }
 
         function parseEmptyStatement(semicolonToken: ISyntaxToken): EmptyStatementSyntax {
@@ -1863,7 +1867,7 @@ module TypeScript.Parser {
             var openParenToken = eatToken(SyntaxKind.OpenParenToken);
 
             var _currentToken = currentToken();
-            var tokenKind = _currentToken.kind();
+            var tokenKind = _currentToken.kind;
             if (tokenKind === SyntaxKind.VarKeyword) {
                 // for ( var VariableDeclarationListNoIn; Expressionopt ; Expressionopt ) Statement
                 // for ( var VariableDeclarationNoIn in Expression ) Statement
@@ -1881,14 +1885,14 @@ module TypeScript.Parser {
         }
 
         function parseForOrForInStatementWithVariableDeclaration(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken): IStatementSyntax {
-            // Debug.assert(forKeyword.kind === SyntaxKind.ForKeyword && openParenToken.kind() === SyntaxKind.OpenParenToken);
-            // Debug.assert(currentToken().kind() === SyntaxKind.VarKeyword);
+            // Debug.assert(forKeyword.kind === SyntaxKind.ForKeyword && openParenToken.kind === SyntaxKind.OpenParenToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.VarKeyword);
 
             // for ( var VariableDeclarationListNoIn; Expressionopt ; Expressionopt ) Statement
             // for ( var VariableDeclarationNoIn in Expression ) Statement
 
             var variableDeclaration = parseVariableDeclaration(/*allowIn:*/ false);
-            return currentToken().kind() === SyntaxKind.InKeyword 
+            return currentToken().kind === SyntaxKind.InKeyword 
                 ? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, undefined)
                 : parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, undefined);
         }
@@ -1902,27 +1906,27 @@ module TypeScript.Parser {
         }
 
         function parseForOrForInStatementWithInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken): IStatementSyntax {
-            // Debug.assert(forKeyword.kind() === SyntaxKind.ForKeyword && openParenToken.kind() === SyntaxKind.OpenParenToken);
+            // Debug.assert(forKeyword.kind === SyntaxKind.ForKeyword && openParenToken.kind === SyntaxKind.OpenParenToken);
 
             // for ( ExpressionNoInopt; Expressionopt ; Expressionopt ) Statement
             // for ( LeftHandSideExpression in Expression ) Statement
 
             var initializer = parseExpression(/*allowIn:*/ false);
-            return currentToken().kind() === SyntaxKind.InKeyword
+            return currentToken().kind === SyntaxKind.InKeyword
                 ? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, undefined, initializer)
                 : parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, undefined, initializer);
         }
 
         function parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken): ForStatementSyntax {
-            // Debug.assert(forKeyword.kind() === SyntaxKind.ForKeyword && openParenToken.kind() === SyntaxKind.OpenParenToken);
-            // Debug.assert(currentToken().kind() === SyntaxKind.SemicolonToken);
+            // Debug.assert(forKeyword.kind === SyntaxKind.ForKeyword && openParenToken.kind === SyntaxKind.OpenParenToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.SemicolonToken);
             // for ( ; Expressionopt ; Expressionopt ) Statement
 
             return parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, /*variableDeclaration:*/ undefined, /*initializer:*/ undefined);
         }
 
         function tryParseForStatementCondition(): IExpressionSyntax {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind !== SyntaxKind.SemicolonToken &&
                 tokenKind !== SyntaxKind.CloseParenToken &&
                 tokenKind !== SyntaxKind.EndOfFileToken) {
@@ -1933,7 +1937,7 @@ module TypeScript.Parser {
         }
 
         function tryParseForStatementIncrementor(): IExpressionSyntax {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind !== SyntaxKind.CloseParenToken &&
                 tokenKind !== SyntaxKind.EndOfFileToken) {
                 return parseExpression(/*allowIn:*/ true);
@@ -2001,7 +2005,7 @@ module TypeScript.Parser {
                 return true;
             }
 
-            var currentTokenKind = currentToken().kind();
+            var currentTokenKind = currentToken().kind;
             return currentTokenKind === SyntaxKind.CaseKeyword || currentTokenKind === SyntaxKind.DefaultKeyword;
         }
 
@@ -2014,7 +2018,7 @@ module TypeScript.Parser {
             }
 
             var _currentToken = currentToken();
-            var kind = _currentToken.kind();
+            var kind = _currentToken.kind;
             if (kind === SyntaxKind.CaseKeyword) {
                 return parseCaseSwitchClause(_currentToken);
             }
@@ -2088,19 +2092,19 @@ module TypeScript.Parser {
 
         function isExpressionStatement(currentToken: ISyntaxToken): boolean {
             // As per the gramar, neither { nor 'function' can start an expression statement.
-            var tokenKind = currentToken.kind();
+            var tokenKind = currentToken.kind;
             return tokenKind !== SyntaxKind.OpenBraceToken && tokenKind !== SyntaxKind.FunctionKeyword && isExpression(currentToken);
         }
 
         function isAssignmentOrOmittedExpression(): boolean {
             var _currentToken = currentToken();
-            return _currentToken.kind() === SyntaxKind.CommaToken || isExpression(_currentToken);
+            return _currentToken.kind === SyntaxKind.CommaToken || isExpression(_currentToken);
         }
 
         function tryParseAssignmentOrOmittedExpression(): IExpressionSyntax {
             // Debug.assert(isAssignmentOrOmittedExpression());
 
-            if (currentToken().kind() === SyntaxKind.CommaToken) {
+            if (currentToken().kind === SyntaxKind.CommaToken) {
                 return new OmittedExpressionSyntax(parseNodeData);
             }
 
@@ -2108,7 +2112,7 @@ module TypeScript.Parser {
         }
 
         function isExpression(currentToken: ISyntaxToken): boolean {
-            switch (currentToken.kind()) {
+            switch (currentToken.kind) {
                 // Literals
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.StringLiteral:
@@ -2189,7 +2193,7 @@ module TypeScript.Parser {
         }
 
         function parseOptionalElseClause(): ElseClauseSyntax {
-            return currentToken().kind() === SyntaxKind.ElseKeyword ? parseElseClause() : undefined;
+            return currentToken().kind === SyntaxKind.ElseKeyword ? parseElseClause() : undefined;
         }
 
         function parseElseClause(): ElseClauseSyntax {
@@ -2197,7 +2201,7 @@ module TypeScript.Parser {
         }
 
         function isVariableStatement(modifierCount: number): boolean {
-            return peekToken(modifierCount).kind() === SyntaxKind.VarKeyword;
+            return peekToken(modifierCount).kind === SyntaxKind.VarKeyword;
         }
 
         function parseVariableStatement(): VariableStatementSyntax {
@@ -2206,7 +2210,7 @@ module TypeScript.Parser {
         }
 
         function parseVariableDeclaration(allowIn: boolean): VariableDeclarationSyntax {
-            // Debug.assert(currentToken().kind() === SyntaxKind.VarKeyword);
+            // Debug.assert(currentToken().kind === SyntaxKind.VarKeyword);
 
             var varKeyword = eatToken(SyntaxKind.VarKeyword);
             // Debug.assert(varKeyword.fullWidth() > 0);
@@ -2224,7 +2228,7 @@ module TypeScript.Parser {
 
         function isVariableDeclarator(): boolean {
             var node = currentNode();
-            if (node && node.kind() === SyntaxKind.VariableDeclarator) {
+            if (node && node.kind === SyntaxKind.VariableDeclarator) {
                 return true;
             }
 
@@ -2232,7 +2236,7 @@ module TypeScript.Parser {
         }
 
         function canReuseVariableDeclaratorNode(node: ISyntaxNode) {
-            if (!node || node.kind() !== SyntaxKind.VariableDeclarator) {
+            if (!node || node.kind !== SyntaxKind.VariableDeclarator) {
                 return false;
             }
 
@@ -2292,7 +2296,7 @@ module TypeScript.Parser {
 
         function isEqualsValueClause(inParameter: boolean): boolean {
             var token0 = currentToken();
-            if (token0.kind() === SyntaxKind.EqualsToken) {
+            if (token0.kind === SyntaxKind.EqualsToken) {
                 return true;
             }
 
@@ -2300,7 +2304,7 @@ module TypeScript.Parser {
             // there is no newline after the last token and if we're on an expression.  If so, parse
             // this as an equals-value clause with a missing equals.
             if (!previousTokenHasTrailingNewLine(token0)) {
-                var tokenKind = token0.kind();
+                var tokenKind = token0.kind;
 
                 // The 'isExpression' call below returns true for "=>".  That's because it smartly
                 // assumes that there is just a missing identifier and the user wanted a lambda.  
@@ -2340,7 +2344,7 @@ module TypeScript.Parser {
             var leftOperand = tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn);
             while (true) {
                 var _currentToken = currentToken();
-                if (_currentToken.kind() !== SyntaxKind.CommaToken) {
+                if (_currentToken.kind !== SyntaxKind.CommaToken) {
                     break;
                 }
 
@@ -2407,7 +2411,7 @@ module TypeScript.Parser {
                 var operatorToken = currentOperatorToken();
 
                 // Check for recursive assignment expressions.
-                if (SyntaxFacts.isAssignmentOperatorToken(operatorToken.kind())) {
+                if (SyntaxFacts.isAssignmentOperatorToken(operatorToken.kind)) {
                     return new BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(operatorToken), 
                         tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn));
                 }
@@ -2424,7 +2428,7 @@ module TypeScript.Parser {
         }
 
         function tryParseUnaryExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IUnaryExpressionSyntax {
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
 
             switch (currentTokenKind) {
                 case SyntaxKind.PlusToken:
@@ -2466,7 +2470,7 @@ module TypeScript.Parser {
             var _currentToken = currentToken();
 
             // Now check for conditional expression.
-            if (_currentToken.kind() !== SyntaxKind.QuestionToken) {
+            if (_currentToken.kind !== SyntaxKind.QuestionToken) {
                 return leftOperand;
             }
 
@@ -2484,7 +2488,7 @@ module TypeScript.Parser {
                 // currentOperatorToken versus currentToken here so that we merge token sequences
                 // like > and = into >=
                 var operatorToken = currentOperatorToken();
-                var tokenKind = operatorToken.kind();
+                var tokenKind = operatorToken.kind;
 
                 // Only proceed if we see binary expression token.  However we don't parse 
                 // assignment expressions or comma expressions here.  Those are taken care of 
@@ -2526,7 +2530,7 @@ module TypeScript.Parser {
 
             // If we see a > we need to see if we can actually merge this contextually into a 
             // >>  >>>  >=  >>=  >>>=  token.
-            if (token0.kind() === SyntaxKind.GreaterThanToken) {
+            if (token0.kind === SyntaxKind.GreaterThanToken) {
                 return currentContextualToken();
                 // var kind = token0.kind;
                 //Debug.assert(kind() === SyntaxKind.GreaterThanToken || kind() === SyntaxKind.GreaterThanGreaterThanToken ||
@@ -2596,7 +2600,7 @@ module TypeScript.Parser {
         function parseCallExpressionRest(expression: ILeftHandSideExpressionSyntax): ILeftHandSideExpressionSyntax {
             while (true) {
                 var _currentToken = currentToken();
-                var currentTokenKind = _currentToken.kind();
+                var currentTokenKind = _currentToken.kind;
 
                 switch (currentTokenKind) {
                     case SyntaxKind.OpenParenToken:
@@ -2637,7 +2641,7 @@ module TypeScript.Parser {
         function parseMemberExpressionRest(expression: IMemberExpressionSyntax, inObjectCreation: boolean): IMemberExpressionSyntax {
             while (true) {
                 var _currentToken = currentToken();
-                var currentTokenKind = _currentToken.kind();
+                var currentTokenKind = _currentToken.kind;
 
                 switch (currentTokenKind) {
                     case SyntaxKind.OpenBracketToken:
@@ -2691,7 +2695,7 @@ module TypeScript.Parser {
             // CallExpression productions.
 
             var expression: ILeftHandSideExpressionSyntax = undefined;
-            if (_currentToken.kind() === SyntaxKind.SuperKeyword) {
+            if (_currentToken.kind === SyntaxKind.SuperKeyword) {
                 expression = parseSuperExpression(_currentToken);
             }
             else {
@@ -2711,7 +2715,7 @@ module TypeScript.Parser {
 
             // If we have seen "super" it must be followed by '(' or '.'.
             // If it wasn't then just try to parse out a '.' and report an error.
-            var currentTokenKind = currentToken().kind();
+            var currentTokenKind = currentToken().kind;
             return currentTokenKind === SyntaxKind.OpenParenToken || currentTokenKind === SyntaxKind.DotToken
                 ? expression
                 : new MemberAccessExpressionSyntax(parseNodeData, expression, eatToken(SyntaxKind.DotToken), eatIdentifierNameToken());
@@ -2724,7 +2728,7 @@ module TypeScript.Parser {
             }
 
             var _currentToken = currentToken();
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
 
             switch (currentTokenKind) {
                 case SyntaxKind.PlusPlusToken:
@@ -2742,14 +2746,14 @@ module TypeScript.Parser {
         }
 
         function tryParseGenericArgumentList(): ArgumentListSyntax {
-            // Debug.assert(currentToken().kind() === SyntaxKind.LessThanToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.LessThanToken);
             // If we have a '<', then only parse this as a arugment list if the type arguments
             // are complete and we have an open paren.  if we don't, rewind and return nothing.
             var rewindPoint = getRewindPoint();
 
             var typeArgumentList = tryParseTypeArgumentList(/*inExpression:*/ true);
             var token0 = currentToken();
-            var tokenKind = token0.kind();
+            var tokenKind = token0.kind;
 
             var isOpenParen = tokenKind === SyntaxKind.OpenParenToken;
             var isDot = tokenKind === SyntaxKind.DotToken;
@@ -2787,7 +2791,7 @@ module TypeScript.Parser {
         }
 
         function tryParseArgumentList(): ArgumentListSyntax {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.LessThanToken) {
                 return tryParseGenericArgumentList();
             }
@@ -2822,14 +2826,14 @@ module TypeScript.Parser {
             // after the open paren, we still want to force parsing an expression (which will
             // cause a missing identiifer to be created), so that we will then consume the
             // comma and the following list items).
-            var force = currentToken().kind() === SyntaxKind.CommaToken;
+            var force = currentToken().kind === SyntaxKind.CommaToken;
             return tryParseAssignmentExpressionOrHigher(force, /*allowIn:*/ true);
         }
 
         function parseElementAccessArgumentExpression(openBracketToken: ISyntaxToken, inObjectCreation: boolean) {
             // It's not uncommon for a user to write: "new Type[]".  Check for that common pattern
             // and report a better error message.
-            if (inObjectCreation && currentToken().kind() === SyntaxKind.CloseBracketToken) {
+            if (inObjectCreation && currentToken().kind === SyntaxKind.CloseBracketToken) {
                 var errorStart = start(openBracketToken, source.text);
                 var errorEnd = end(currentToken(), source.text);
                 var diagnostic = new Diagnostic(fileName, source.text.lineMap(), errorStart, errorEnd - errorStart,
@@ -2844,7 +2848,7 @@ module TypeScript.Parser {
         }
 
         function parseElementAccessExpression(expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, inObjectCreation: boolean): ElementAccessExpressionSyntax {
-            // Debug.assert(currentToken().kind() === SyntaxKind.OpenBracketToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.OpenBracketToken);
             return new ElementAccessExpressionSyntax(parseNodeData, expression, consumeToken(openBracketToken),
                 parseElementAccessArgumentExpression(openBracketToken, inObjectCreation), eatToken(SyntaxKind.CloseBracketToken));
         }
@@ -2854,7 +2858,7 @@ module TypeScript.Parser {
                 return eatIdentifierToken();
             }
 
-            var currentTokenKind = _currentToken.kind();
+            var currentTokenKind = _currentToken.kind;
             switch (currentTokenKind) {
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.TrueKeyword:
@@ -2901,7 +2905,7 @@ module TypeScript.Parser {
             // contexts.
 
             // var currentToken = this.currentToken();
-            // Debug.assert(SyntaxFacts.isAnyDivideToken(currentToken.kind()));
+            // Debug.assert(SyntaxFacts.isAnyDivideToken(currentToken.kind));
 
             // Ok, from our quick lexical check, this could be a place where a regular expression could
             // go.  Now we have to do a bunch of work.  Ask the source to retrive the token at the 
@@ -2910,9 +2914,9 @@ module TypeScript.Parser {
 
             // Note: we *must* have gotten a /, /= or regular expression.  Or else something went *very*
             // wrong with our logic above.
-            // Debug.assert(SyntaxFacts.isAnyDivideOrRegularExpressionToken(currentToken.kind()));
+            // Debug.assert(SyntaxFacts.isAnyDivideOrRegularExpressionToken(currentToken.kind));
 
-            var tokenKind = currentToken.kind();
+            var tokenKind = currentToken.kind;
             if (tokenKind === SyntaxKind.SlashToken || tokenKind === SyntaxKind.SlashEqualsToken) {
                 // Still came back as a / or /=.   This is not a regular expression literal.
                 return undefined;
@@ -2963,7 +2967,7 @@ module TypeScript.Parser {
         function parseTemplateExpression(startToken: ISyntaxToken): IPrimaryExpressionSyntax {
             consumeToken(startToken);
 
-            if (startToken.kind() === SyntaxKind.NoSubstitutionTemplateToken) {
+            if (startToken.kind === SyntaxKind.NoSubstitutionTemplateToken) {
                 return startToken;
             }
             
@@ -2974,7 +2978,7 @@ module TypeScript.Parser {
                 // middle pieces.
                 templateClauses.push(parseTemplateClause());
             }
-            while (templateClauses[templateClauses.length - 1].templateMiddleOrEndToken.kind() === SyntaxKind.TemplateMiddleToken);
+            while (templateClauses[templateClauses.length - 1].templateMiddleOrEndToken.kind === SyntaxKind.TemplateMiddleToken);
             
             return new TemplateExpressionSyntax(parseNodeData, startToken, Syntax.list(templateClauses));
         }
@@ -2983,9 +2987,9 @@ module TypeScript.Parser {
             var expression = parseExpression(/*allowIn:*/ true);
             var token = currentToken();
 
-            if (token.kind() === SyntaxKind.CloseBraceToken) {
+            if (token.kind === SyntaxKind.CloseBraceToken) {
                 token = currentContextualToken();
-                Debug.assert(token.kind() === SyntaxKind.TemplateMiddleToken || token.kind() === SyntaxKind.TemplateEndToken);
+                Debug.assert(token.kind === SyntaxKind.TemplateMiddleToken || token.kind === SyntaxKind.TemplateEndToken);
                 consumeToken(token);
             }
             else {
@@ -3008,7 +3012,7 @@ module TypeScript.Parser {
         }
 
         function tryParseParenthesizedArrowFunctionExpression(): ParenthesizedArrowFunctionExpressionSyntax {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind !== SyntaxKind.OpenParenToken && tokenKind !== SyntaxKind.LessThanToken) {
                 return undefined;
             }
@@ -3048,11 +3052,11 @@ module TypeScript.Parser {
 
         function tryParseParenthesizedArrowFunctionExpressionWorker(requireArrow: boolean): ParenthesizedArrowFunctionExpressionSyntax {
             var _currentToken = currentToken();
-            // Debug.assert(currentToken.kind() === SyntaxKind.OpenParenToken || currentToken.kind() === SyntaxKind.LessThanToken);
+            // Debug.assert(currentToken.kind === SyntaxKind.OpenParenToken || currentToken.kind === SyntaxKind.LessThanToken);
 
             var callSignature = parseCallSignature(/*requireCompleteTypeParameterList:*/ true);
 
-            if (requireArrow && currentToken().kind() !== SyntaxKind.EqualsGreaterThanToken) {
+            if (requireArrow && currentToken().kind !== SyntaxKind.EqualsGreaterThanToken) {
                 return undefined;
             }
 
@@ -3100,12 +3104,12 @@ module TypeScript.Parser {
             // ERROR RECOVERY TWEAK:
             // If we see a standalone => try to parse it as an arrow function as that's likely what
             // the user intended to write.
-            if (_currentToken.kind() === SyntaxKind.EqualsGreaterThanToken) {
+            if (_currentToken.kind === SyntaxKind.EqualsGreaterThanToken) {
                 return true;
             }
 
             return isIdentifier(_currentToken) &&
-                   peekToken(1).kind() === SyntaxKind.EqualsGreaterThanToken;
+                   peekToken(1).kind === SyntaxKind.EqualsGreaterThanToken;
         }
 
         function parseSimpleArrowFunctionExpression(): SimpleArrowFunctionExpressionSyntax {
@@ -3124,19 +3128,19 @@ module TypeScript.Parser {
         }
 
         function isBlock(): boolean {
-            return currentToken().kind() === SyntaxKind.OpenBraceToken;
+            return currentToken().kind === SyntaxKind.OpenBraceToken;
         }
 
         function isDefinitelyArrowFunctionExpression(): boolean {
             var token0 = currentToken();
-            if (token0.kind() !== SyntaxKind.OpenParenToken) {
+            if (token0.kind !== SyntaxKind.OpenParenToken) {
                 // If it didn't start with an (, then it could be generic.  That's too complicated 
                 // and we can't say it's 'definitely' an arrow function.             
                 return false;
             }
 
             var token1 = peekToken(1);
-            var token1Kind = token1.kind();
+            var token1Kind = token1.kind;
 
             var token2: ISyntaxToken;
 
@@ -3149,7 +3153,7 @@ module TypeScript.Parser {
                 //      "():"  or  "() =>"  or "() {}".  Note: the last one is illegal.  However it
                 // most likely is a missing => and not a parenthesized expression.
                 token2 = peekToken(2);
-                var token2Kind = token2.kind();
+                var token2Kind = token2.kind;
                 return token2Kind === SyntaxKind.ColonToken ||
                        token2Kind === SyntaxKind.EqualsGreaterThanToken ||
                        token2Kind === SyntaxKind.OpenBraceToken;
@@ -3162,7 +3166,7 @@ module TypeScript.Parser {
             }
 
             token2 = peekToken(2); 
-            token2Kind = token2.kind();
+            token2Kind = token2.kind;
 
             if (SyntaxFacts.isAccessibilityModifier(token1Kind)) {
                 if (isIdentifier(token2)) {
@@ -3191,7 +3195,7 @@ module TypeScript.Parser {
             }
 
             var token3 = peekToken(3);
-            var token3Kind = token3.kind();
+            var token3Kind = token3.kind;
             if (token2Kind === SyntaxKind.QuestionToken) {
                 // (id?
                 // Could be an arrow function, or a parenthesized conditional expression.
@@ -3234,7 +3238,7 @@ module TypeScript.Parser {
 
         function isPossiblyArrowFunctionExpression(): boolean {
             var token0 = currentToken();
-            if (token0.kind() !== SyntaxKind.OpenParenToken) {
+            if (token0.kind !== SyntaxKind.OpenParenToken) {
                 // If it didn't start with an (, then it could be generic.  That's too complicated 
                 // and we have to say it's possibly an arrow function.
                 return true;
@@ -3249,7 +3253,7 @@ module TypeScript.Parser {
             }
 
             var token2 = peekToken(2);
-            var token2Kind = token2.kind();
+            var token2Kind = token2.kind;
             if (token2Kind === SyntaxKind.EqualsToken) {
                 // (id =
                 //
@@ -3272,7 +3276,7 @@ module TypeScript.Parser {
                 // (id)
 
                 var token3 = peekToken(3);
-                if (token3.kind() === SyntaxKind.ColonToken) {
+                if (token3.kind === SyntaxKind.ColonToken) {
                     // (id):
                     //
                     // This could be an arrow function. i.e. (id): number => { }
@@ -3287,7 +3291,7 @@ module TypeScript.Parser {
         }
 
         function parseObjectLiteralExpression(openBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax {
-            // Debug.assert(currentToken().kind() === SyntaxKind.OpenBraceToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.OpenBraceToken);
 
             consumeToken(openBraceToken);
             // Debug.assert(openBraceToken.fullWidth() > 0);
@@ -3370,12 +3374,12 @@ module TypeScript.Parser {
 
             // We allow a template literal while parser for error tolerance.  We'll report errors
             // on this later in the grammar checker walker.
-            var kind = token.kind();
+            var kind = token.kind;
             return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.NoSubstitutionTemplateToken;
         }
 
         function parseArrayLiteralExpression(openBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax {
-            // Debug.assert(currentToken().kind() === SyntaxKind.OpenBracketToken);
+            // Debug.assert(currentToken().kind === SyntaxKind.OpenBracketToken);
             consumeToken(openBracketToken);
             // Debug.assert(openBracketToken.fullWidth() > 0);
 
@@ -3411,7 +3415,7 @@ module TypeScript.Parser {
 
         function tryParseTypeParameterList(requireCompleteTypeParameterList: boolean): TypeParameterListSyntax {
             var _currentToken = currentToken();
-            if (_currentToken.kind() !== SyntaxKind.LessThanToken) {
+            if (_currentToken.kind !== SyntaxKind.LessThanToken) {
                 return undefined;
             }
 
@@ -3451,7 +3455,7 @@ module TypeScript.Parser {
         }
 
         function tryParseConstraint(): ConstraintSyntax {
-            if (currentToken().kind() !== SyntaxKind.ExtendsKeyword) {
+            if (currentToken().kind !== SyntaxKind.ExtendsKeyword) {
                 return undefined;
             }
 
@@ -3459,10 +3463,10 @@ module TypeScript.Parser {
         }
 
         function tryParseParameterList(): ParameterListSyntax {
-            if (currentToken().kind() === SyntaxKind.OpenParenToken) {
+            if (currentToken().kind === SyntaxKind.OpenParenToken) {
                 var token1 = peekToken(1);
 
-                if (token1.kind() === SyntaxKind.CloseParenToken || isParameterHelper(token1)) {
+                if (token1.kind === SyntaxKind.CloseParenToken || isParameterHelper(token1)) {
                     return parseParameterList();
                 }
             }
@@ -3484,13 +3488,13 @@ module TypeScript.Parser {
         }
 
         function parseOptionalTypeAnnotation(allowStringLiteral: boolean): TypeAnnotationSyntax {
-            return currentToken().kind() === SyntaxKind.ColonToken ? parseTypeAnnotation(allowStringLiteral) : undefined;
+            return currentToken().kind === SyntaxKind.ColonToken ? parseTypeAnnotation(allowStringLiteral) : undefined;
         }
 
         function parseTypeAnnotationType(allowStringLiteral: boolean): ITypeSyntax {
             if (allowStringLiteral) {
                 var _currentToken = currentToken();
-                if (_currentToken.kind() === SyntaxKind.StringLiteral) {
+                if (_currentToken.kind === SyntaxKind.StringLiteral) {
                     return consumeToken(_currentToken);
                 }
             }
@@ -3505,7 +3509,7 @@ module TypeScript.Parser {
         function isType(): boolean {
             var _currentToken = currentToken();
 
-            switch (_currentToken.kind()) {
+            switch (_currentToken.kind) {
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.NumberKeyword:
@@ -3553,7 +3557,7 @@ module TypeScript.Parser {
                 return parseFunctionType();
             }
 
-            if (currentToken().kind() === SyntaxKind.NewKeyword) {
+            if (currentToken().kind === SyntaxKind.NewKeyword) {
                 return parseConstructorType();
             }
 
@@ -3565,7 +3569,7 @@ module TypeScript.Parser {
 
             if (type) {
                 var barToken: ISyntaxToken;
-                while ((barToken = currentToken()).kind() === SyntaxKind.BarToken) {
+                while ((barToken = currentToken()).kind === SyntaxKind.BarToken) {
                     consumeToken(barToken);
                     var right = parsePrimaryType();
 
@@ -3593,7 +3597,7 @@ module TypeScript.Parser {
                 var _currentToken = currentToken();
 
                 if (previousTokenHasTrailingNewLine(_currentToken) ||
-                    _currentToken.kind() !== SyntaxKind.OpenBracketToken) {
+                    _currentToken.kind !== SyntaxKind.OpenBracketToken) {
                     break;
                 }
 
@@ -3609,14 +3613,14 @@ module TypeScript.Parser {
 
         function tryParseNonArrayType(): ITypeSyntax {
             var _currentToken = currentToken();
-            switch (_currentToken.kind()) {
+            switch (_currentToken.kind) {
                 case SyntaxKind.AnyKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
                 case SyntaxKind.StringKeyword:
                     // if any of these are followed by '.', then this is actually a module name,
                     // and these keywords will be reinterpreted as an identifier.
-                    if (peekToken(1).kind() === SyntaxKind.DotToken) {
+                    if (peekToken(1).kind === SyntaxKind.DotToken) {
                         break;
                     }
 
@@ -3657,7 +3661,7 @@ module TypeScript.Parser {
 
         function isFunctionType(): boolean {
             var token0 = currentToken();
-            var token0Kind = token0.kind();
+            var token0Kind = token0.kind;
 
             // If we see a  <  then we consider ourselves to be definitely in a (generic) function type.
             if (token0Kind === SyntaxKind.LessThanToken) {
@@ -3671,7 +3675,7 @@ module TypeScript.Parser {
             // parenthesized type.
             if (token0Kind === SyntaxKind.OpenParenToken) {
                 var token1 = peekToken(1);
-                var token1Kind = token1.kind();
+                var token1Kind = token1.kind;
 
                 if (token1Kind === SyntaxKind.CloseParenToken || token1Kind === SyntaxKind.DotDotDotToken) {
                     // () 
@@ -3686,7 +3690,7 @@ module TypeScript.Parser {
                     // could be a function type or a parenthesized type.
 
                     var token2 = peekToken(2);
-                    var token2Kind = token2.kind();
+                    var token2Kind = token2.kind;
 
                     if (token2Kind === SyntaxKind.ColonToken ||
                         token2Kind === SyntaxKind.CommaToken ||
@@ -3708,7 +3712,7 @@ module TypeScript.Parser {
                         // ( id )
                         //
                         // Only a function type if we see an arrow following it.
-                        return peekToken(3).kind() === SyntaxKind.EqualsGreaterThanToken;
+                        return peekToken(3).kind === SyntaxKind.EqualsGreaterThanToken;
                     }
                 }
             }
@@ -3732,7 +3736,7 @@ module TypeScript.Parser {
         }
 
         function isParameter(): boolean {
-            if (currentNode() && currentNode().kind() === SyntaxKind.Parameter) {
+            if (currentNode() && currentNode().kind === SyntaxKind.Parameter) {
                 return true;
             }
 
@@ -3740,7 +3744,7 @@ module TypeScript.Parser {
         }
 
         function isParameterHelper(token: ISyntaxToken): boolean {
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
             return tokenKind === SyntaxKind.DotDotDotToken ||
                    isModifierKind(tokenKind) ||
                    isIdentifier(token);
@@ -3754,7 +3758,7 @@ module TypeScript.Parser {
 
         function tryParseParameter(): ParameterSyntax {
             var node = currentNode();
-            if (node && node.kind() === SyntaxKind.Parameter) {
+            if (node && node.kind === SyntaxKind.Parameter) {
                 consumeNode(node);
                 return <ParameterSyntax>node;
             }
@@ -3770,7 +3774,7 @@ module TypeScript.Parser {
                 // If we see a modifier alone in a parameter list, like:      foo(static)
                 //
                 // then treat it like modifier, and continue parsing the parameter.
-                if (isModifierKind(_currentToken.kind())) {
+                if (isModifierKind(_currentToken.kind)) {
                     modifiers = Syntax.list([consumeToken(_currentToken)]);
                 }
                 else {
@@ -3864,7 +3868,7 @@ module TypeScript.Parser {
         }
 
         function tryParseExpectedListItem(
-                currentListType: ListParsingState, inErrorRecovery: boolean, items: ISyntaxElement[], processItems: (items: any[]) => void): boolean {
+                currentListType: ListParsingState, inErrorRecovery: boolean, items: ISyntaxNodeOrToken[], processItems: (items: ISyntaxNodeOrToken[]) => void): boolean {
             var item = tryParseExpectedListItemWorker(currentListType, inErrorRecovery);
 
             if (item === undefined) {
@@ -3883,10 +3887,10 @@ module TypeScript.Parser {
 
         function listIsTerminated(currentListType: ListParsingState): boolean {
             return isExpectedListTerminator(currentListType) ||
-                   currentToken().kind() === SyntaxKind.EndOfFileToken;
+                   currentToken().kind === SyntaxKind.EndOfFileToken;
         }
 
-        function parseSyntaxListWorker<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[], processItems: (items: any[]) => void ): T[] {
+        function parseSyntaxListWorker<T extends ISyntaxNodeOrToken>(currentListType: ListParsingState, skippedTokens: ISyntaxToken[], processItems: (items: ISyntaxNodeOrToken[]) => void ): T[] {
             var items: T[] = [];
 
             while (true) {
@@ -3973,7 +3977,7 @@ module TypeScript.Parser {
                 // allow 'comma' as a separator (for error tolerance).  We will later do a post pass
                 // to report when a comma was used improperly in a list that needed semicolons.
                 var _currentToken = currentToken();
-                var tokenKind = _currentToken.kind();
+                var tokenKind = _currentToken.kind;
                 if (tokenKind === _separatorKind || tokenKind === SyntaxKind.CommaToken) {
                     // Consume the last separator and continue parsing list elements.
                     nodesAndSeparators.push(consumeToken(_currentToken));
@@ -4081,32 +4085,32 @@ module TypeScript.Parser {
         }
 
         function isExpectedSourceUnit_ModuleElementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.EndOfFileToken;
+            return currentToken().kind === SyntaxKind.EndOfFileToken;
         }
 
         function isExpectedEnumDeclaration_EnumElementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedModuleDeclaration_ModuleElementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedObjectType_TypeMembersTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedLiteralExpression_AssignmentExpressionsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBracketToken;
+            return currentToken().kind === SyntaxKind.CloseBracketToken;
         }
 
         function isExpectedTypeArgumentList_TypesTerminator(): boolean {
             var token = currentToken();
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
             if (tokenKind === SyntaxKind.GreaterThanToken) {
                 return true;
             }
@@ -4123,7 +4127,7 @@ module TypeScript.Parser {
 
         function isExpectedTupleType_TypesTerminator(): boolean {
             var token = currentToken();
-            var tokenKind = token.kind();
+            var tokenKind = token.kind;
             if (tokenKind === SyntaxKind.CloseBracketToken) {
                 return true;
             }
@@ -4133,7 +4137,7 @@ module TypeScript.Parser {
         }
 
         function isExpectedTypeParameterList_TypeParametersTerminator(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.GreaterThanToken) {
                 return true;
             }
@@ -4151,7 +4155,7 @@ module TypeScript.Parser {
         }
 
         function isExpectedParameterList_ParametersTerminator(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.CloseParenToken) {
                 return true;
             }
@@ -4172,7 +4176,7 @@ module TypeScript.Parser {
         }
 
         function isExpectedIndexSignature_ParametersTerminator() {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.CloseBracketToken) {
                 return true;
             }
@@ -4188,7 +4192,7 @@ module TypeScript.Parser {
 
         function isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator(): boolean {
             // This is the case when we're parsing variable declarations in a for/for-in statement.
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
 
             if (tokenKind === SyntaxKind.SemicolonToken ||
                 tokenKind === SyntaxKind.CloseParenToken) {
@@ -4209,7 +4213,7 @@ module TypeScript.Parser {
             // For better error recovery, if we see a => then we just stop immediately.  We've got an
             // arrow function here and it's going to be very unlikely that we'll resynchronize and get
             // another variable declaration.
-            if (currentToken().kind() === SyntaxKind.EqualsGreaterThanToken) {
+            if (currentToken().kind === SyntaxKind.EqualsGreaterThanToken) {
                 return true;
             }
 
@@ -4218,7 +4222,7 @@ module TypeScript.Parser {
         }
 
         function isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.OpenBraceToken || tokenKind === SyntaxKind.CloseBraceToken) {
                 return true;
             }
@@ -4227,7 +4231,7 @@ module TypeScript.Parser {
         }
 
         function isExpectedHeritageClause_TypeNameListTerminator(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             if (tokenKind === SyntaxKind.ExtendsKeyword || tokenKind === SyntaxKind.ImplementsKeyword) {
                 return true;
             }
@@ -4241,36 +4245,36 @@ module TypeScript.Parser {
 
         function isExpectedArgumentList_AssignmentExpressionsTerminator(): boolean {
             var token0 = currentToken();
-            var tokenKind = token0.kind();
+            var tokenKind = token0.kind;
             return tokenKind === SyntaxKind.CloseParenToken ||
                    tokenKind === SyntaxKind.SemicolonToken;
         }
 
         function isExpectedClassDeclaration_ClassElementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedSwitchStatement_SwitchClausesTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedSwitchClause_StatementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken ||
+            return currentToken().kind === SyntaxKind.CloseBraceToken ||
                    isSwitchClause();
         }
 
         function isExpectedBlock_StatementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.CloseBraceToken;
+            return currentToken().kind === SyntaxKind.CloseBraceToken;
         }
 
         function isExpectedTryBlock_StatementsTerminator(): boolean {
-            var tokenKind = currentToken().kind();
+            var tokenKind = currentToken().kind;
             return tokenKind === SyntaxKind.CatchKeyword ||
                     tokenKind === SyntaxKind.FinallyKeyword;
         }
 
         function isExpectedCatchBlock_StatementsTerminator(): boolean {
-            return currentToken().kind() === SyntaxKind.FinallyKeyword;
+            return currentToken().kind === SyntaxKind.FinallyKeyword;
         }
 
         function isExpectedListItem(currentListType: ListParsingState, inErrorRecovery: boolean): any {
@@ -4314,7 +4318,7 @@ module TypeScript.Parser {
             // If we're on a comma then the user has written something like "Foo(a,," or "Foo(,".
             // Instead of skipping the comma, create an empty expression to go before the comma 
             // so that the tree is more well formed and doesn't have skipped tokens.
-            if (_currentToken.kind() === SyntaxKind.CommaToken) {
+            if (_currentToken.kind === SyntaxKind.CommaToken) {
                 return true;
             }
 
diff --git a/src/services/syntax/prettyPrinter.ts b/src/services/syntax/prettyPrinter.ts
index 3d926fcfdee..efee0a9e294 100644
--- a/src/services/syntax/prettyPrinter.ts
+++ b/src/services/syntax/prettyPrinter.ts
@@ -20,7 +20,7 @@ module TypeScript.PrettyPrinter {
                 return 0;
             }
 
-            if (lastToken(element1).kind() === SyntaxKind.CloseBraceToken) {
+            if (lastToken(element1).kind === SyntaxKind.CloseBraceToken) {
                 return 2;
             }
 
@@ -40,7 +40,7 @@ module TypeScript.PrettyPrinter {
                 return 0;
             }
 
-            if (lastToken(element1).kind() === SyntaxKind.CloseBraceToken) {
+            if (lastToken(element1).kind === SyntaxKind.CloseBraceToken) {
                 return 2;
             }
 
@@ -552,7 +552,7 @@ module TypeScript.PrettyPrinter {
         public visitBinaryExpression(node: BinaryExpressionSyntax): void {
             visitNodeOrToken(this, node.left);
 
-            if (node.operatorToken.kind() !== SyntaxKind.CommaToken) {
+            if (node.operatorToken.kind !== SyntaxKind.CommaToken) {
                 this.ensureSpace();
             }
 
@@ -628,7 +628,7 @@ module TypeScript.PrettyPrinter {
         }
 
         private appendBlockOrStatement(node: IStatementSyntax): void {
-            if (node.kind() === SyntaxKind.Block) {
+            if (node.kind === SyntaxKind.Block) {
                 this.ensureSpace();
                 visitNodeOrToken(this, node);
             }
@@ -654,7 +654,7 @@ module TypeScript.PrettyPrinter {
             this.ensureNewLine();
             this.appendToken(node.elseKeyword);
 
-            if (node.statement.kind() === SyntaxKind.IfStatement) {
+            if (node.statement.kind === SyntaxKind.IfStatement) {
                 this.ensureSpace();
                 visitNodeOrToken(this, node.statement);
             }
@@ -774,7 +774,7 @@ module TypeScript.PrettyPrinter {
         }
 
         private appendSwitchClauseStatements(node: ISwitchClauseSyntax): void {
-            if (childCount(node.statements) === 1 && childAt(node.statements, 0).kind() === SyntaxKind.Block) {
+            if (childCount(node.statements) === 1 && childAt(node.statements, 0).kind === SyntaxKind.Block) {
                 this.ensureSpace();
                 visitNodeOrToken(this, node.statements[0]);
             }
diff --git a/src/services/syntax/scanner.ts b/src/services/syntax/scanner.ts
index 759559672c4..67c40d87902 100644
--- a/src/services/syntax/scanner.ts
+++ b/src/services/syntax/scanner.ts
@@ -60,84 +60,52 @@ module TypeScript.Scanner {
     // This gives us 23bit for width (or 8MB of width which should be enough for any codebase).
 
     enum ScannerConstants {
-        LargeTokenFullStartShift           = 4,
-        LargeTokenFullWidthShift           = 7,
-        LargeTokenLeadingTriviaBitMask     = 0x01, // 00000001
-        LargeTokenLeadingCommentBitMask    = 0x02, // 00000010
-        LargeTokenTrailingTriviaBitMask    = 0x04, // 00000100
-        LargeTokenTrailingCommentBitMask   = 0x08, // 00001000
-        LargeTokenTriviaBitMask            = 0x0F, // 00001111
+        LargeTokenFullWidthShift        = 6,
+        LargeTokenLeadingTriviaShift    = 3,
 
-        FixedWidthTokenFullStartShift      = 7,
-        FixedWidthTokenMaxFullStart        = 0x7FFFFF, // 23 ones.
+        WhitespaceTrivia                = 0x01, // 00000001
+        NewlineTrivia                   = 0x02, // 00000010
+        CommentTrivia                   = 0x04, // 00000100
+        TriviaMask                      = 0x07, // 00000111
 
-        SmallTokenFullWidthShift           = 7,
-        SmallTokenFullStartShift           = 12,
-        SmallTokenMaxFullStart             = 0x3FFFF,  // 18 ones.
-        SmallTokenMaxFullWidth             = 0x1F,     // 5 ones
-        SmallTokenFullWidthMask            = 0x1F, // 00011111
-
-        KindMask                           = 0x7F, // 01111111
-        IsVariableWidthMask                = 0x80, // 10000000
+        KindMask                        = 0x7F, // 01111111
+        IsVariableWidthMask             = 0x80, // 10000000
     }
 
-    // Make sure our math works for packing/unpacking large fullStarts.
-    Debug.assert(largeTokenUnpackFullStart(largeTokenPackFullStartAndInfo(1 << 26, 3)) === (1 << 26));
-    Debug.assert(largeTokenUnpackFullStart(largeTokenPackFullStartAndInfo(3 << 25, 1)) === (3 << 25));
-    Debug.assert(largeTokenUnpackFullStart(largeTokenPackFullStartAndInfo(10 << 23, 2)) === (10 << 23));
-
-    function fixedWidthTokenPackData(fullStart: number, kind: SyntaxKind) {
-        return (fullStart << ScannerConstants.FixedWidthTokenFullStartShift) | kind;
+    function largeTokenPackData(fullWidth: number, leadingTriviaInfo: number, trailingTriviaInfo: number) {
+        return (fullWidth << ScannerConstants.LargeTokenFullWidthShift) | (leadingTriviaInfo << ScannerConstants.LargeTokenLeadingTriviaShift) | trailingTriviaInfo;
     }
 
-    function fixedWidthTokenUnpackFullStart(packedData: number) {
-        return packedData >> ScannerConstants.FixedWidthTokenFullStartShift;
+    function largeTokenUnpackFullWidth(packedFullWidthAndInfo: number): number {
+        return packedFullWidthAndInfo >> ScannerConstants.LargeTokenFullWidthShift;
     }
 
-    function smallTokenPackData(fullStart: number, fullWidth: number, kind: SyntaxKind) {
-        return (fullStart << ScannerConstants.SmallTokenFullStartShift) |
-            (fullWidth << ScannerConstants.SmallTokenFullWidthShift) |
-            kind;
+    function largeTokenUnpackLeadingTriviaInfo(packedFullWidthAndInfo: number): number {
+        return (packedFullWidthAndInfo >> ScannerConstants.LargeTokenLeadingTriviaShift) & ScannerConstants.TriviaMask;
     }
 
-    function smallTokenUnpackFullWidth(packedData: number): SyntaxKind {
-        return (packedData >> ScannerConstants.SmallTokenFullWidthShift) & ScannerConstants.SmallTokenFullWidthMask;
-    }
-
-    function smallTokenUnpackFullStart(packedData: number): number {
-        return packedData >> ScannerConstants.SmallTokenFullStartShift;
-    }
-
-    function largeTokenPackFullStartAndInfo(fullStart: number, triviaInfo: number): number {
-        return (fullStart << ScannerConstants.LargeTokenFullStartShift) | triviaInfo;
-    }
-
-    function largeTokenUnpackFullWidth(packedFullWidthAndKind: number) {
-        return packedFullWidthAndKind >> ScannerConstants.LargeTokenFullWidthShift;
-    }
-
-    function largeTokenUnpackFullStart(packedFullStartAndInfo: number): number {
-        return packedFullStartAndInfo >> ScannerConstants.LargeTokenFullStartShift;
+    function largeTokenUnpackTrailingTriviaInfo(packedFullWidthAndInfo: number): number {
+        return packedFullWidthAndInfo & ScannerConstants.TriviaMask;
     }
 
     function largeTokenUnpackHasLeadingTrivia(packed: number): boolean {
-        return (packed & ScannerConstants.LargeTokenLeadingTriviaBitMask) !== 0;
+        return largeTokenUnpackLeadingTriviaInfo(packed) !== 0;
     }
 
     function largeTokenUnpackHasTrailingTrivia(packed: number): boolean {
-        return (packed & ScannerConstants.LargeTokenTrailingTriviaBitMask) !== 0;
+        return largeTokenUnpackTrailingTriviaInfo(packed) !== 0;
+    }
+
+    function hasComment(info: number) {
+        return (info & ScannerConstants.CommentTrivia) !== 0;
     }
 
     function largeTokenUnpackHasLeadingComment(packed: number): boolean {
-        return (packed & ScannerConstants.LargeTokenLeadingCommentBitMask) !== 0;
+        return hasComment(largeTokenUnpackLeadingTriviaInfo(packed));
     }
 
     function largeTokenUnpackHasTrailingComment(packed: number): boolean {
-        return (packed & ScannerConstants.LargeTokenTrailingCommentBitMask) !== 0;
-    }
-
-    function largeTokenUnpackTriviaInfo(packed: number): number {
-        return packed & ScannerConstants.LargeTokenTriviaBitMask;
+        return hasComment(largeTokenUnpackTrailingTriviaInfo(packed));
     }
 
     var isKeywordStartCharacter: number[] = ArrayUtilities.createArray<number>(CharacterCodes.maxAsciiCharacter, 0);
@@ -166,7 +134,7 @@ module TypeScript.Scanner {
         // These tokens are contextually created based on parsing decisions.  We can't reuse 
         // them in incremental scenarios as we may be in a context where the parser would not
         // create them.
-        switch (token.kind()) {
+        switch (token.kind) {
             // Created by the parser when it sees / or /= in a location where it needs an expression.
             case SyntaxKind.RegularExpressionLiteral:
 
@@ -254,11 +222,11 @@ module TypeScript.Scanner {
         public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
         public parent: ISyntaxElement;
 
-        constructor(private _packedData: number) {
+        constructor(private _fullStart: number, public kind: SyntaxKind) {
         }
 
         public setFullStart(fullStart: number): void {
-            this._packedData = fixedWidthTokenPackData(fullStart, this.kind());
+            this._fullStart = fullStart;
         }
 
         public childCount() { return 0 }
@@ -268,21 +236,20 @@ module TypeScript.Scanner {
         public isIncrementallyUnusable(): boolean { return false; }
         public isKeywordConvertedToIdentifier(): boolean { return false; }
         public hasSkippedToken(): boolean { return false; }
-        public fullText(): string { return SyntaxFacts.getText(this.kind()); }
+        public fullText(): string { return SyntaxFacts.getText(this.kind); }
         public text(): string { return this.fullText(); }
         public leadingTrivia(): ISyntaxTriviaList { return Syntax.emptyTriviaList; }
         public trailingTrivia(): ISyntaxTriviaList { return Syntax.emptyTriviaList; }
         public leadingTriviaWidth(): number { return 0; }
         public trailingTriviaWidth(): number { return 0; }
 
-        public kind(): SyntaxKind { return this._packedData & ScannerConstants.KindMask; }
-        public fullWidth(): number { return fixedWidthTokenLength(this._packedData & ScannerConstants.KindMask); }
-        public fullStart(): number { return fixedWidthTokenUnpackFullStart(this._packedData); }
+        public fullWidth(): number { return fixedWidthTokenLength(this.kind); }
+        public fullStart(): number { return this._fullStart; }
         public hasLeadingTrivia(): boolean { return false; }
         public hasTrailingTrivia(): boolean { return false; }
         public hasLeadingComment(): boolean { return false; }
         public hasTrailingComment(): boolean { return false; }
-        public clone(): ISyntaxToken { return new FixedWidthTokenWithNoTrivia(this._packedData); }
+        public clone(): ISyntaxToken { return new FixedWidthTokenWithNoTrivia(this._fullStart, this.kind); }
     }
 
     class LargeScannerToken implements ISyntaxToken {
@@ -291,15 +258,14 @@ module TypeScript.Scanner {
 
         private cachedText: string;
 
-        constructor(private _packedFullStartAndInfo: number, private _packedFullWidthAndKind: number, cachedText: string) {
+        constructor(private _fullStart: number, public kind: SyntaxKind, private _packedFullWidthAndInfo: number, cachedText: string) {
             if (cachedText !== undefined) {
                 this.cachedText = cachedText;
             }
         }
 
         public setFullStart(fullStart: number): void {
-            this._packedFullStartAndInfo = largeTokenPackFullStartAndInfo(fullStart,
-                largeTokenUnpackTriviaInfo(this._packedFullStartAndInfo));
+            this._fullStart = fullStart;
         }
 
         public childCount() { return 0 }
@@ -322,7 +288,7 @@ module TypeScript.Scanner {
 
         public text(): string {
             var cachedText = this.cachedText;
-            return cachedText !== undefined ? cachedText : SyntaxFacts.getText(this.kind());
+            return cachedText !== undefined ? cachedText : SyntaxFacts.getText(this.kind);
         }
 
         public leadingTrivia(text?: ISimpleText): ISyntaxTriviaList { return leadingTrivia(this, this.syntaxTreeText(text)); }
@@ -336,14 +302,13 @@ module TypeScript.Scanner {
             return trailingTriviaWidth(this, this.syntaxTreeText(text));
         }
 
-        public kind(): SyntaxKind { return this._packedFullWidthAndKind & ScannerConstants.KindMask; }
-        public fullWidth(): number { return largeTokenUnpackFullWidth(this._packedFullWidthAndKind); }
-        public fullStart(): number { return largeTokenUnpackFullStart(this._packedFullStartAndInfo); }
-        public hasLeadingTrivia(): boolean { return largeTokenUnpackHasLeadingTrivia(this._packedFullStartAndInfo); }
-        public hasTrailingTrivia(): boolean { return largeTokenUnpackHasTrailingTrivia(this._packedFullStartAndInfo); }
-        public hasLeadingComment(): boolean { return largeTokenUnpackHasLeadingComment(this._packedFullStartAndInfo); }
-        public hasTrailingComment(): boolean { return largeTokenUnpackHasTrailingComment(this._packedFullStartAndInfo); }
-        public clone(): ISyntaxToken { return new LargeScannerToken(this._packedFullStartAndInfo, this._packedFullWidthAndKind, this.cachedText); }
+        public fullWidth(): number { return largeTokenUnpackFullWidth(this._packedFullWidthAndInfo); }
+        public fullStart(): number { return this._fullStart; }
+        public hasLeadingTrivia(): boolean { return largeTokenUnpackHasLeadingTrivia(this._packedFullWidthAndInfo); }
+        public hasTrailingTrivia(): boolean { return largeTokenUnpackHasTrailingTrivia(this._packedFullWidthAndInfo); }
+        public hasLeadingComment(): boolean { return largeTokenUnpackHasLeadingComment(this._packedFullWidthAndInfo); }
+        public hasTrailingComment(): boolean { return largeTokenUnpackHasTrailingComment(this._packedFullWidthAndInfo); }
+        public clone(): ISyntaxToken { return new LargeScannerToken(this._fullStart, this.kind, this._packedFullWidthAndInfo, this.cachedText); }
     }
 
     export interface DiagnosticCallback {
@@ -384,12 +349,13 @@ module TypeScript.Scanner {
         }
 
         function reset(_text: ISimpleText, _start: number, _end: number) {
-            Debug.assert(_start <= _text.length(), "Token's start was not within the bounds of text: " + _start + " - [0, " + _text.length() + ")");
-            Debug.assert(_end <= _text.length(), "Token's end was not within the bounds of text: " + _end + " - [0, " + _text.length() + ")");
+            var textLength = _text.length();
+            Debug.assert(_start <= textLength, "Token's start was not within the bounds of text.");
+            Debug.assert(_end <= textLength, "Token's end was not within the bounds of text:");
 
             if (!str || text !== _text) {
                 text = _text;
-                str = _text.substr(0, _text.length());
+                str = _text.substr(0, textLength);
             }
 
             start = _start;
@@ -416,20 +382,14 @@ module TypeScript.Scanner {
                 ((kindAndIsVariableWidth & ScannerConstants.IsVariableWidthMask) === 0);
 
             if (isFixedWidth &&
-                leadingTriviaInfo === 0 && trailingTriviaInfo === 0 &&
-                fullStart <= ScannerConstants.FixedWidthTokenMaxFullStart &&
-                (kindAndIsVariableWidth & ScannerConstants.IsVariableWidthMask) === 0) {
+                leadingTriviaInfo === 0 && trailingTriviaInfo === 0) {
 
-                return new FixedWidthTokenWithNoTrivia((fullStart << ScannerConstants.FixedWidthTokenFullStartShift) | kind);
+                return new FixedWidthTokenWithNoTrivia(fullStart, kind);
             }
             else {
-                // inline the packing logic for perf.  
-                var packedFullStartAndTriviaInfo = (fullStart << ScannerConstants.LargeTokenFullStartShift) |
-                    leadingTriviaInfo | (trailingTriviaInfo << 2);
-
-                var packedFullWidthAndKind = (fullWidth << ScannerConstants.LargeTokenFullWidthShift) | kind;
+                var packedFullWidthAndInfo = largeTokenPackData(fullWidth, leadingTriviaInfo, trailingTriviaInfo);
                 var cachedText = isFixedWidth ? undefined : text.substr(start, end - start);
-                return new LargeScannerToken(packedFullStartAndTriviaInfo, packedFullWidthAndKind, cachedText);
+                return new LargeScannerToken(fullStart, kind, packedFullWidthAndInfo, cachedText);
             }
         }
 
@@ -539,7 +499,7 @@ module TypeScript.Scanner {
                     case CharacterCodes.formFeed:
                         index++;
                         // we have trivia
-                        result |= 1;
+                        result |= ScannerConstants.WhitespaceTrivia;
                         continue;
 
                     case CharacterCodes.carriageReturn:
@@ -548,10 +508,12 @@ module TypeScript.Scanner {
                         }
                     // fall through.
                     case CharacterCodes.lineFeed:
+                    case CharacterCodes.paragraphSeparator:
+                    case CharacterCodes.lineSeparator:
                         index++;
 
                         // we have trivia
-                        result |= 1;
+                        result |= ScannerConstants.NewlineTrivia;
 
                         // If we're consuming leading trivia, then we will continue consuming more 
                         // trivia (including newlines) up to the first token we see.  If we're 
@@ -567,14 +529,14 @@ module TypeScript.Scanner {
                             var ch2 = str.charCodeAt(index + 1);
                             if (ch2 === CharacterCodes.slash) {
                                 // we have a comment, and we have trivia
-                                result |= 3;
+                                result |= ScannerConstants.CommentTrivia;
                                 skipSingleLineCommentTrivia();
                                 continue;
                             }
 
                             if (ch2 === CharacterCodes.asterisk) {
                                 // we have a comment, and we have trivia
-                                result |= 3;
+                                result |= ScannerConstants.CommentTrivia;
                                 skipMultiLineCommentTrivia();
                                 continue;
                             }
@@ -584,8 +546,8 @@ module TypeScript.Scanner {
                         return result;
 
                     default:
-                        if (ch > CharacterCodes.maxAsciiCharacter && slowScanTriviaInfo(ch)) {
-                            result |= 1;
+                        if (ch > CharacterCodes.maxAsciiCharacter && slowScanWhitespaceTriviaInfo(ch)) {
+                            result |= ScannerConstants.WhitespaceTrivia;
                             continue;
                         }
 
@@ -596,7 +558,7 @@ module TypeScript.Scanner {
             return result;
         }
 
-        function slowScanTriviaInfo(ch: number): boolean {
+        function slowScanWhitespaceTriviaInfo(ch: number): boolean {
             switch (ch) {
                 case CharacterCodes.nonBreakingSpace:
                 case CharacterCodes.enQuad:
@@ -614,8 +576,6 @@ module TypeScript.Scanner {
                 case CharacterCodes.narrowNoBreakSpace:
                 case CharacterCodes.ideographicSpace:
                 case CharacterCodes.byteOrderMark:
-                case CharacterCodes.paragraphSeparator:
-                case CharacterCodes.lineSeparator:
                     index++;
                     return true;
 
@@ -1688,11 +1648,14 @@ module TypeScript.Scanner {
 
         function resetToPosition(absolutePosition: number): void {
             Debug.assert(absolutePosition <= text.length(), "Trying to set the position outside the bounds of the text!");
+            var resetBackward = absolutePosition <= _absolutePosition;
 
             _absolutePosition = absolutePosition;
 
-            // First, remove any diagnostics that came after this position.
-            removeDiagnosticsOnOrAfterPosition(absolutePosition);
+            if (resetBackward) {
+                // First, remove any diagnostics that came after this position.
+                removeDiagnosticsOnOrAfterPosition(absolutePosition);
+            }
 
             // Now, tell our sliding window to throw away all tokens after this position as well.
             slidingWindow.disgardAllItemsFromCurrentIndexOnwards();
@@ -1704,7 +1667,7 @@ module TypeScript.Scanner {
 
         function currentContextualToken(): ISyntaxToken {
             // We better be on a / or > token right now.
-            // Debug.assert(SyntaxFacts.isAnyDivideToken(currentToken().kind()));
+            // Debug.assert(SyntaxFacts.isAnyDivideToken(currentToken().kind));
 
             // First, we're going to rewind all our data to the point where this / or /= token started.
             // That's because if it does turn out to be a regular expression, then any tokens or token 
@@ -1724,7 +1687,7 @@ module TypeScript.Scanner {
 
             // We have better gotten some sort of regex token.  Otherwise, something *very* wrong has
             // occurred.
-            // Debug.assert(SyntaxFacts.isAnyDivideOrRegularExpressionToken(token.kind()));
+            // Debug.assert(SyntaxFacts.isAnyDivideOrRegularExpressionToken(token.kind));
 
             return token;
         }
@@ -1749,114 +1712,8 @@ module TypeScript.Scanner {
         };
     }
 
+    var fixedWidthArray = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 8, 8, 7, 6, 2, 4, 5, 7, 3, 8, 2, 2, 10, 3, 4, 6, 6, 4, 5, 4, 3, 6, 3, 4, 5, 4, 5, 5, 4, 6, 7, 6, 5, 10, 9, 3, 7, 7, 9, 6, 6, 5, 3, 7, 11, 7, 3, 6, 7, 6, 3, 6, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, 3, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 2, 2, 2, 1, 2];
     function fixedWidthTokenLength(kind: SyntaxKind) {
-        switch (kind) {
-            case SyntaxKind.BreakKeyword: return 5;
-            case SyntaxKind.CaseKeyword: return 4;
-            case SyntaxKind.CatchKeyword: return 5;
-            case SyntaxKind.ContinueKeyword: return 8;
-            case SyntaxKind.DebuggerKeyword: return 8;
-            case SyntaxKind.DefaultKeyword: return 7;
-            case SyntaxKind.DeleteKeyword: return 6;
-            case SyntaxKind.DoKeyword: return 2;
-            case SyntaxKind.ElseKeyword: return 4;
-            case SyntaxKind.FalseKeyword: return 5;
-            case SyntaxKind.FinallyKeyword: return 7;
-            case SyntaxKind.ForKeyword: return 3;
-            case SyntaxKind.FunctionKeyword: return 8;
-            case SyntaxKind.IfKeyword: return 2;
-            case SyntaxKind.InKeyword: return 2;
-            case SyntaxKind.InstanceOfKeyword: return 10;
-            case SyntaxKind.NewKeyword: return 3;
-            case SyntaxKind.NullKeyword: return 4;
-            case SyntaxKind.ReturnKeyword: return 6;
-            case SyntaxKind.SwitchKeyword: return 6;
-            case SyntaxKind.ThisKeyword: return 4;
-            case SyntaxKind.ThrowKeyword: return 5;
-            case SyntaxKind.TrueKeyword: return 4;
-            case SyntaxKind.TryKeyword: return 3;
-            case SyntaxKind.TypeOfKeyword: return 6;
-            case SyntaxKind.VarKeyword: return 3;
-            case SyntaxKind.VoidKeyword: return 4;
-            case SyntaxKind.WhileKeyword: return 5;
-            case SyntaxKind.WithKeyword: return 4;
-            case SyntaxKind.ClassKeyword: return 5;
-            case SyntaxKind.ConstKeyword: return 5;
-            case SyntaxKind.EnumKeyword: return 4;
-            case SyntaxKind.ExportKeyword: return 6;
-            case SyntaxKind.ExtendsKeyword: return 7;
-            case SyntaxKind.ImportKeyword: return 6;
-            case SyntaxKind.SuperKeyword: return 5;
-            case SyntaxKind.ImplementsKeyword: return 10;
-            case SyntaxKind.InterfaceKeyword: return 9;
-            case SyntaxKind.LetKeyword: return 3;
-            case SyntaxKind.PackageKeyword: return 7;
-            case SyntaxKind.PrivateKeyword: return 7;
-            case SyntaxKind.ProtectedKeyword: return 9;
-            case SyntaxKind.PublicKeyword: return 6;
-            case SyntaxKind.StaticKeyword: return 6;
-            case SyntaxKind.YieldKeyword: return 5;
-            case SyntaxKind.AnyKeyword: return 3;
-            case SyntaxKind.BooleanKeyword: return 7;
-            case SyntaxKind.ConstructorKeyword: return 11;
-            case SyntaxKind.DeclareKeyword: return 7;
-            case SyntaxKind.GetKeyword: return 3;
-            case SyntaxKind.ModuleKeyword: return 6;
-            case SyntaxKind.RequireKeyword: return 7;
-            case SyntaxKind.NumberKeyword: return 6;
-            case SyntaxKind.SetKeyword: return 3;
-            case SyntaxKind.StringKeyword: return 6;
-            case SyntaxKind.OpenBraceToken: return 1;
-            case SyntaxKind.CloseBraceToken: return 1;
-            case SyntaxKind.OpenParenToken: return 1;
-            case SyntaxKind.CloseParenToken: return 1;
-            case SyntaxKind.OpenBracketToken: return 1;
-            case SyntaxKind.CloseBracketToken: return 1;
-            case SyntaxKind.DotToken: return 1;
-            case SyntaxKind.DotDotDotToken: return 3;
-            case SyntaxKind.SemicolonToken: return 1;
-            case SyntaxKind.CommaToken: return 1;
-            case SyntaxKind.LessThanToken: return 1;
-            case SyntaxKind.GreaterThanToken: return 1;
-            case SyntaxKind.LessThanEqualsToken: return 2;
-            case SyntaxKind.GreaterThanEqualsToken: return 2;
-            case SyntaxKind.EqualsEqualsToken: return 2;
-            case SyntaxKind.EqualsGreaterThanToken: return 2;
-            case SyntaxKind.ExclamationEqualsToken: return 2;
-            case SyntaxKind.EqualsEqualsEqualsToken: return 3;
-            case SyntaxKind.ExclamationEqualsEqualsToken: return 3;
-            case SyntaxKind.PlusToken: return 1;
-            case SyntaxKind.MinusToken: return 1;
-            case SyntaxKind.AsteriskToken: return 1;
-            case SyntaxKind.PercentToken: return 1;
-            case SyntaxKind.PlusPlusToken: return 2;
-            case SyntaxKind.MinusMinusToken: return 2;
-            case SyntaxKind.LessThanLessThanToken: return 2;
-            case SyntaxKind.GreaterThanGreaterThanToken: return 2;
-            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: return 3;
-            case SyntaxKind.AmpersandToken: return 1;
-            case SyntaxKind.BarToken: return 1;
-            case SyntaxKind.CaretToken: return 1;
-            case SyntaxKind.ExclamationToken: return 1;
-            case SyntaxKind.TildeToken: return 1;
-            case SyntaxKind.AmpersandAmpersandToken: return 2;
-            case SyntaxKind.BarBarToken: return 2;
-            case SyntaxKind.QuestionToken: return 1;
-            case SyntaxKind.ColonToken: return 1;
-            case SyntaxKind.EqualsToken: return 1;
-            case SyntaxKind.PlusEqualsToken: return 2;
-            case SyntaxKind.MinusEqualsToken: return 2;
-            case SyntaxKind.AsteriskEqualsToken: return 2;
-            case SyntaxKind.PercentEqualsToken: return 2;
-            case SyntaxKind.LessThanLessThanEqualsToken: return 3;
-            case SyntaxKind.GreaterThanGreaterThanEqualsToken: return 3;
-            case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return 4;
-            case SyntaxKind.AmpersandEqualsToken: return 2;
-            case SyntaxKind.BarEqualsToken: return 2;
-            case SyntaxKind.CaretEqualsToken: return 2;
-            case SyntaxKind.SlashToken: return 1;
-            case SyntaxKind.SlashEqualsToken: return 2;
-            default: throw new Error();
-        }
+        return fixedWidthArray[kind];
     }
 }
\ No newline at end of file
diff --git a/src/services/syntax/scannerUtilities.generated.ts b/src/services/syntax/scannerUtilities.generated.ts
index 9e1a018006b..97f0093a672 100644
--- a/src/services/syntax/scannerUtilities.generated.ts
+++ b/src/services/syntax/scannerUtilities.generated.ts
@@ -2,117 +2,6 @@
 
 module TypeScript {
     export module ScannerUtilities {
-        export function fixedWidthTokenLength(kind: SyntaxKind) {
-            switch (kind) {
-                case SyntaxKind.BreakKeyword: return 5;
-                case SyntaxKind.CaseKeyword: return 4;
-                case SyntaxKind.CatchKeyword: return 5;
-                case SyntaxKind.ContinueKeyword: return 8;
-                case SyntaxKind.DebuggerKeyword: return 8;
-                case SyntaxKind.DefaultKeyword: return 7;
-                case SyntaxKind.DeleteKeyword: return 6;
-                case SyntaxKind.DoKeyword: return 2;
-                case SyntaxKind.ElseKeyword: return 4;
-                case SyntaxKind.FalseKeyword: return 5;
-                case SyntaxKind.FinallyKeyword: return 7;
-                case SyntaxKind.ForKeyword: return 3;
-                case SyntaxKind.FunctionKeyword: return 8;
-                case SyntaxKind.IfKeyword: return 2;
-                case SyntaxKind.InKeyword: return 2;
-                case SyntaxKind.InstanceOfKeyword: return 10;
-                case SyntaxKind.NewKeyword: return 3;
-                case SyntaxKind.NullKeyword: return 4;
-                case SyntaxKind.ReturnKeyword: return 6;
-                case SyntaxKind.SwitchKeyword: return 6;
-                case SyntaxKind.ThisKeyword: return 4;
-                case SyntaxKind.ThrowKeyword: return 5;
-                case SyntaxKind.TrueKeyword: return 4;
-                case SyntaxKind.TryKeyword: return 3;
-                case SyntaxKind.TypeOfKeyword: return 6;
-                case SyntaxKind.VarKeyword: return 3;
-                case SyntaxKind.VoidKeyword: return 4;
-                case SyntaxKind.WhileKeyword: return 5;
-                case SyntaxKind.WithKeyword: return 4;
-                case SyntaxKind.ClassKeyword: return 5;
-                case SyntaxKind.ConstKeyword: return 5;
-                case SyntaxKind.EnumKeyword: return 4;
-                case SyntaxKind.ExportKeyword: return 6;
-                case SyntaxKind.ExtendsKeyword: return 7;
-                case SyntaxKind.ImportKeyword: return 6;
-                case SyntaxKind.SuperKeyword: return 5;
-                case SyntaxKind.ImplementsKeyword: return 10;
-                case SyntaxKind.InterfaceKeyword: return 9;
-                case SyntaxKind.LetKeyword: return 3;
-                case SyntaxKind.PackageKeyword: return 7;
-                case SyntaxKind.PrivateKeyword: return 7;
-                case SyntaxKind.ProtectedKeyword: return 9;
-                case SyntaxKind.PublicKeyword: return 6;
-                case SyntaxKind.StaticKeyword: return 6;
-                case SyntaxKind.YieldKeyword: return 5;
-                case SyntaxKind.AnyKeyword: return 3;
-                case SyntaxKind.BooleanKeyword: return 7;
-                case SyntaxKind.ConstructorKeyword: return 11;
-                case SyntaxKind.DeclareKeyword: return 7;
-                case SyntaxKind.GetKeyword: return 3;
-                case SyntaxKind.ModuleKeyword: return 6;
-                case SyntaxKind.RequireKeyword: return 7;
-                case SyntaxKind.NumberKeyword: return 6;
-                case SyntaxKind.SetKeyword: return 3;
-                case SyntaxKind.StringKeyword: return 6;
-                case SyntaxKind.OpenBraceToken: return 1;
-                case SyntaxKind.CloseBraceToken: return 1;
-                case SyntaxKind.OpenParenToken: return 1;
-                case SyntaxKind.CloseParenToken: return 1;
-                case SyntaxKind.OpenBracketToken: return 1;
-                case SyntaxKind.CloseBracketToken: return 1;
-                case SyntaxKind.DotToken: return 1;
-                case SyntaxKind.DotDotDotToken: return 3;
-                case SyntaxKind.SemicolonToken: return 1;
-                case SyntaxKind.CommaToken: return 1;
-                case SyntaxKind.LessThanToken: return 1;
-                case SyntaxKind.GreaterThanToken: return 1;
-                case SyntaxKind.LessThanEqualsToken: return 2;
-                case SyntaxKind.GreaterThanEqualsToken: return 2;
-                case SyntaxKind.EqualsEqualsToken: return 2;
-                case SyntaxKind.EqualsGreaterThanToken: return 2;
-                case SyntaxKind.ExclamationEqualsToken: return 2;
-                case SyntaxKind.EqualsEqualsEqualsToken: return 3;
-                case SyntaxKind.ExclamationEqualsEqualsToken: return 3;
-                case SyntaxKind.PlusToken: return 1;
-                case SyntaxKind.MinusToken: return 1;
-                case SyntaxKind.AsteriskToken: return 1;
-                case SyntaxKind.PercentToken: return 1;
-                case SyntaxKind.PlusPlusToken: return 2;
-                case SyntaxKind.MinusMinusToken: return 2;
-                case SyntaxKind.LessThanLessThanToken: return 2;
-                case SyntaxKind.GreaterThanGreaterThanToken: return 2;
-                case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: return 3;
-                case SyntaxKind.AmpersandToken: return 1;
-                case SyntaxKind.BarToken: return 1;
-                case SyntaxKind.CaretToken: return 1;
-                case SyntaxKind.ExclamationToken: return 1;
-                case SyntaxKind.TildeToken: return 1;
-                case SyntaxKind.AmpersandAmpersandToken: return 2;
-                case SyntaxKind.BarBarToken: return 2;
-                case SyntaxKind.QuestionToken: return 1;
-                case SyntaxKind.ColonToken: return 1;
-                case SyntaxKind.EqualsToken: return 1;
-                case SyntaxKind.PlusEqualsToken: return 2;
-                case SyntaxKind.MinusEqualsToken: return 2;
-                case SyntaxKind.AsteriskEqualsToken: return 2;
-                case SyntaxKind.PercentEqualsToken: return 2;
-                case SyntaxKind.LessThanLessThanEqualsToken: return 3;
-                case SyntaxKind.GreaterThanGreaterThanEqualsToken: return 3;
-                case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return 4;
-                case SyntaxKind.AmpersandEqualsToken: return 2;
-                case SyntaxKind.BarEqualsToken: return 2;
-                case SyntaxKind.CaretEqualsToken: return 2;
-                case SyntaxKind.SlashToken: return 1;
-                case SyntaxKind.SlashEqualsToken: return 2;
-                default: throw new Error();
-            }
-        }
-
         export function identifierKind(str: string, start: number, length: number): SyntaxKind {
             switch (length) {
               case 2: // do, if, in
diff --git a/src/services/syntax/syntax.ts b/src/services/syntax/syntax.ts
index 99741977751..cac2c280d24 100644
--- a/src/services/syntax/syntax.ts
+++ b/src/services/syntax/syntax.ts
@@ -9,7 +9,7 @@ module TypeScript.Syntax {
             if (isToken(child)) {
                 var token = <ISyntaxToken>child;
                 // If a token is skipped, return true. Or if it is a missing token. The only empty token that is not missing is EOF
-                if (token.hasSkippedToken() || (width(token) === 0 && token.kind() !== SyntaxKind.EndOfFileToken)) {
+                if (token.hasSkippedToken() || (width(token) === 0 && token.kind !== SyntaxKind.EndOfFileToken)) {
                     return true;
                 }
             }
@@ -19,7 +19,7 @@ module TypeScript.Syntax {
     }
 
     export function isUnterminatedStringLiteral(token: ISyntaxToken): boolean {
-        if (token && token.kind() === SyntaxKind.StringLiteral) {
+        if (token && token.kind === SyntaxKind.StringLiteral) {
             var text = token.text();
             return text.length < 2 || text.charCodeAt(text.length - 1) !== text.charCodeAt(0);
         }
@@ -55,7 +55,7 @@ module TypeScript.Syntax {
         var triviaList: ISyntaxTriviaList = undefined;
         var lastTriviaBeforeToken: ISyntaxTrivia = undefined;
 
-        if (positionedToken.kind() === SyntaxKind.EndOfFileToken) {
+        if (positionedToken.kind === SyntaxKind.EndOfFileToken) {
             // Check if the trivia is leading on the EndOfFile token
             if (positionedToken.hasLeadingTrivia()) {
                 triviaList = positionedToken.leadingTrivia();
@@ -106,14 +106,14 @@ module TypeScript.Syntax {
         var positionedToken = findToken(sourceUnit, position);
 
         if (positionedToken) {
-            if (positionedToken.kind() === SyntaxKind.EndOfFileToken) {
+            if (positionedToken.kind === SyntaxKind.EndOfFileToken) {
                 // EndOfFile token, enusre it did not follow an unterminated string literal
                 positionedToken = previousToken(positionedToken);
                 return positionedToken && positionedToken.trailingTriviaWidth() === 0 && isUnterminatedStringLiteral(positionedToken);
             }
             else if (position > start(positionedToken)) {
                 // Ensure position falls enterily within the literal if it is terminated, or the line if it is not
-                return (position < end(positionedToken) && (positionedToken.kind() === TypeScript.SyntaxKind.StringLiteral || positionedToken.kind() === TypeScript.SyntaxKind.RegularExpressionLiteral)) ||
+                return (position < end(positionedToken) && (positionedToken.kind === TypeScript.SyntaxKind.StringLiteral || positionedToken.kind === TypeScript.SyntaxKind.RegularExpressionLiteral)) ||
                     (position <= end(positionedToken) && isUnterminatedStringLiteral(positionedToken));
             }
         }
@@ -123,7 +123,7 @@ module TypeScript.Syntax {
 
     export function getAncestorOfKind(positionedToken: ISyntaxElement, kind: SyntaxKind): ISyntaxElement {
         while (positionedToken && positionedToken.parent) {
-            if (positionedToken.parent.kind() === kind) {
+            if (positionedToken.parent.kind === kind) {
                 return positionedToken.parent;
             }
 
@@ -139,10 +139,10 @@ module TypeScript.Syntax {
 
     export function isIntegerLiteral(expression: IExpressionSyntax): boolean {
         if (expression) {
-            switch (expression.kind()) {
+            switch (expression.kind) {
                 case SyntaxKind.PrefixUnaryExpression:
                     var prefixExpr = <PrefixUnaryExpressionSyntax>expression;
-                    if (prefixExpr.operatorToken.kind() == SyntaxKind.PlusToken || prefixExpr.operatorToken.kind() === SyntaxKind.MinusToken) {
+                    if (prefixExpr.operatorToken.kind == SyntaxKind.PlusToken || prefixExpr.operatorToken.kind === SyntaxKind.MinusToken) {
                         // Note: if there is a + or - sign, we can only allow a normal integer following
                         // (and not a hex integer).  i.e. -0xA is a legal expression, but it is not a 
                         // *literal*.
diff --git a/src/services/syntax/syntaxElement.ts b/src/services/syntax/syntaxElement.ts
index 6b6dc7d4a7a..e42d9d44cdb 100644
--- a/src/services/syntax/syntaxElement.ts
+++ b/src/services/syntax/syntaxElement.ts
@@ -6,7 +6,7 @@ module TypeScript {
             // Debug.assert(!isShared(element));
 
             while (element) {
-                if (element.kind() === SyntaxKind.SourceUnit) {
+                if (element.kind === SyntaxKind.SourceUnit) {
                     return (<SourceUnitSyntax>element).syntaxTree;
                 }
 
@@ -53,7 +53,7 @@ module TypeScript {
             throw Errors.argumentOutOfRange("position");
         }
 
-        var token = findTokenWorker(sourceUnit, 0, position);
+        var token = findTokenInNodeOrToken(sourceUnit, 0, position);
         if (token) {
             Debug.assert(token.fullWidth() > 0);
             return token;
@@ -113,13 +113,40 @@ module TypeScript {
     }
 
     function findTokenWorker(element: ISyntaxElement, elementPosition: number, position: number): ISyntaxToken {
-        if (isToken(element)) {
-            return <ISyntaxToken>element;
+        if (isList(element)) {
+            return findTokenInList(<ISyntaxNodeOrToken[]>element, elementPosition, position);
+        }
+        else {
+            return findTokenInNodeOrToken(<ISyntaxNodeOrToken>element, elementPosition, position);
+        }
+    }
+
+    function findTokenInList(list: ISyntaxNodeOrToken[], elementPosition: number, position: number): ISyntaxToken {
+        for (var i = 0, n = list.length; i < n; i++) {
+            var child = list[i];
+
+            var childFullWidth = fullWidth(child);
+            var elementEndPosition = elementPosition + childFullWidth;
+
+            if (position < elementEndPosition) {
+                return findTokenWorker(child, elementPosition, position);
+            }
+
+            elementPosition = elementEndPosition;
         }
 
-        // Consider: we could use a binary search here to find the child more quickly.
-        for (var i = 0, n = childCount(element); i < n; i++) {
-            var child = childAt(element, i);
+        return undefined;
+    }
+
+
+    function findTokenInNodeOrToken(nodeOrToken: ISyntaxNodeOrToken, elementPosition: number, position: number): ISyntaxToken {
+        if (isToken(nodeOrToken)) {
+            return <ISyntaxToken>nodeOrToken;
+        }
+
+        var childAtFunction = getChildAtFunction(nodeOrToken);
+        for (var i = 0, n = childCount(nodeOrToken); i < n; i++) {
+            var child = childAtFunction(nodeOrToken, i);
 
             if (child) {
                 var childFullWidth = fullWidth(child);
@@ -137,7 +164,7 @@ module TypeScript {
     }
 
     function tryGetEndOfFileAt(element: ISyntaxElement, position: number): ISyntaxToken {
-        if (element.kind() === SyntaxKind.SourceUnit && position === fullWidth(element)) {
+        if (element.kind === SyntaxKind.SourceUnit && position === fullWidth(element)) {
             var sourceUnit = <SourceUnitSyntax>element;
             return sourceUnit.endOfFileToken;
         }
@@ -146,7 +173,7 @@ module TypeScript {
     }
 
     export function nextToken(token: ISyntaxToken, text?: ISimpleText): ISyntaxToken {
-        if (token.kind() === SyntaxKind.EndOfFileToken) {
+        if (token.kind === SyntaxKind.EndOfFileToken) {
             return undefined;
         }
 
@@ -155,7 +182,7 @@ module TypeScript {
 
     export function isNode(element: ISyntaxElement): boolean {
         if (element) {
-            var kind = element.kind();
+            var kind = element.kind;
             return kind >= SyntaxKind.FirstNode && kind <= SyntaxKind.LastNode;
         }
 
@@ -168,7 +195,7 @@ module TypeScript {
 
     export function isToken(element: ISyntaxElement): boolean {
         if (element) {
-            return isTokenKind(element.kind());
+            return isTokenKind(element.kind);
         }
 
         return false;
@@ -227,7 +254,7 @@ module TypeScript {
 
     export function firstToken(element: ISyntaxElement): ISyntaxToken {
         if (element) {
-            var kind = element.kind();
+            var kind = element.kind;
 
             if (isTokenKind(kind)) {
                 return (<ISyntaxToken>element).fullWidth() > 0 || kind === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
@@ -246,10 +273,10 @@ module TypeScript {
 
     export function lastToken(element: ISyntaxElement): ISyntaxToken {
         if (isToken(element)) {
-            return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
+            return fullWidth(element) > 0 || element.kind === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
         }
 
-        if (element.kind() === SyntaxKind.SourceUnit) {
+        if (element.kind === SyntaxKind.SourceUnit) {
             return (<SourceUnitSyntax>element).endOfFileToken;
         }
 
@@ -366,7 +393,7 @@ module TypeScript {
     }
 
     export interface ISyntaxElement {
-        kind(): SyntaxKind;
+        kind: SyntaxKind;
         parent: ISyntaxElement;
     }
 
diff --git a/src/services/syntax/syntaxFacts2.ts b/src/services/syntax/syntaxFacts2.ts
index 99a144176a4..7c73eb31513 100644
--- a/src/services/syntax/syntaxFacts2.ts
+++ b/src/services/syntax/syntaxFacts2.ts
@@ -2,16 +2,8 @@
 
 module TypeScript.SyntaxFacts {
     export function isDirectivePrologueElement(node: ISyntaxNodeOrToken): boolean {
-        if (node.kind() === SyntaxKind.ExpressionStatement) {
-            var expressionStatement = <ExpressionStatementSyntax>node;
-            var expression = expressionStatement.expression;
-
-            if (expression.kind() === SyntaxKind.StringLiteral) {
-                return true;
-            }
-        }
-
-        return false;
+        return node.kind === SyntaxKind.ExpressionStatement &&
+            (<ExpressionStatementSyntax>node).expression.kind === SyntaxKind.StringLiteral;
     }
 
     export function isUseStrictDirective(node: ISyntaxNodeOrToken): boolean {
@@ -23,7 +15,7 @@ module TypeScript.SyntaxFacts {
     }
 
     export function isIdentifierNameOrAnyKeyword(token: ISyntaxToken): boolean {
-        var tokenKind = token.kind();
+        var tokenKind = token.kind;
         return tokenKind === SyntaxKind.IdentifierName || SyntaxFacts.isAnyKeyword(tokenKind);
     }
 
diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts
index c1adb4afacc..a9ae6ff5d53 100644
--- a/src/services/syntax/syntaxGenerator.ts
+++ b/src/services/syntax/syntaxGenerator.ts
@@ -1153,7 +1153,7 @@ function generateConstructorFunction(definition: ITypeDefinition) {
     }
 
     result += "    };\r\n";
-    result += "    " + definition.name + ".prototype.kind = function() { return SyntaxKind." + getNameWithoutSuffix(definition) + "; }\r\n";
+    result += "    " + definition.name + ".prototype.kind = SyntaxKind." + getNameWithoutSuffix(definition) + ";\r\n";
 
     return result;
 }
@@ -1401,22 +1401,44 @@ function max<T>(array: T[], func: (v: T) => number): number {
     return max;
 }
 
+function generateUtilities(): string {
+    var result = "";
+    result += "        var fixedWidthArray = [";
+    for (var i = 0; i <= TypeScript.SyntaxKind.LastFixedWidth; i++) {
+        if (i) {
+            result += ", ";
+        }
+
+        if (i < TypeScript.SyntaxKind.FirstFixedWidth) {
+            result += "0";
+        }
+        else {
+            result += TypeScript.SyntaxFacts.getText(i).length;
+        }
+    }
+    result += "];\r\n";
+
+    result += "        function fixedWidthTokenLength(kind: SyntaxKind) {\r\n";
+    result += "            return fixedWidthArray[kind];\r\n";
+
+    //result += "            switch (kind) {\r\n";
+
+    //for (var k = TypeScript.SyntaxKind.FirstFixedWidth; k <= TypeScript.SyntaxKind.LastFixedWidth; k++) {
+    //    result += "                case SyntaxKind." + syntaxKindName(k) + ": return " + TypeScript.SyntaxFacts.getText(k).length + ";\r\n";
+    //}
+    //result += "                default: throw new Error();\r\n";
+    //result += "            }\r\n";
+    result += "        }\r\n";
+
+    return result;
+}
+
 function generateScannerUtilities(): string {
     var result = "///<reference path='references.ts' />\r\n" +
         "\r\n" +
         "module TypeScript {\r\n" +
         "    export module ScannerUtilities {\r\n";
 
-    result += "        export function fixedWidthTokenLength(kind: SyntaxKind) {\r\n";
-    result += "            switch (kind) {\r\n";
-
-    for (var k = TypeScript.SyntaxKind.FirstFixedWidth; k <= TypeScript.SyntaxKind.LastFixedWidth; k++) {
-        result += "                case SyntaxKind." + syntaxKindName(k) + ": return " + TypeScript.SyntaxFacts.getText(k).length + ";\r\n";
-    }
-    result += "                default: throw new Error();\r\n";
-    result += "            }\r\n";
-    result += "        }\r\n\r\n";
-
     var i: number;
     var keywords: { text: string; kind: TypeScript.SyntaxKind; }[] = [];
 
@@ -1470,7 +1492,7 @@ function generateVisitor(): string {
     result += "    export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {\r\n";
     result += "        if (element === undefined) { return undefined; }\r\n";
 
-    result += "        switch (element.kind()) {\r\n";
+    result += "        switch (element.kind) {\r\n";
 
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
@@ -1512,7 +1534,7 @@ function generateServicesUtilities(): string {
             result += "0";
         }
         else {
-            var definition = TypeScript.ArrayUtilities.first(definitions,d => firstKind(d) === i);
+            var definition = TypeScript.ArrayUtilities.first(definitions, d => firstKind(d) === i);
             result += definition.children.length;
         }
     }
@@ -1520,40 +1542,80 @@ function generateServicesUtilities(): string {
 
     result += "    export function childCount(element: ISyntaxElement): number {\r\n";
     result += "        if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }\r\n";
-    result += "        return childCountArray[element.kind()];\r\n";
+    result += "        return childCountArray[element.kind];\r\n";
     result += "    }\r\n\r\n";
 
+    result += "    var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [\r\n        ";
+
+    for (var i = 0; i < TypeScript.SyntaxKind.FirstNode; i++) {
+        if (i) {
+            result += ", ";
+        }
+
+        result += "undefined";
+    }
+
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
-        result += "    function " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(node: " + definition.name + ", index: number): ISyntaxElement {\r\n";
+        result += ",\r\n"
+        result += "        (node: " + definition.name + ", index: number): ISyntaxElement => {\r\n";
+
         if (definition.children.length) {
-            result += "        switch (index) {\r\n";
+            result += "            switch (index) {\r\n";
 
             for (var j = 0; j < definition.children.length; j++) {
-                result += "            case " + j + ": return node." + definition.children[j].name + ";\r\n";
+                result += "                case " + j + ": return node." + definition.children[j].name + ";\r\n";
             }
 
-            result += "        }\r\n";
+            result += "            }\r\n";
         }
         else {
-            result += "        throw Errors.invalidOperation();\r\n";
+            result += "            throw Errors.invalidOperation();\r\n";
         }
-        result += "    }\r\n";
+
+
+        result += "        }";
     }
 
+    result += "\r\n    ];\r\n";
+
+    //for (var i = 0; i < definitions.length; i++) {
+    //    var definition = definitions[i];
+    //    result += "    function " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(node: " + definition.name + ", index: number): ISyntaxElement {\r\n";
+    //    if (definition.children.length) {
+    //        result += "        switch (index) {\r\n";
+
+    //        for (var j = 0; j < definition.children.length; j++) {
+    //            result += "            case " + j + ": return node." + definition.children[j].name + ";\r\n";
+    //        }
+
+    //        result += "        }\r\n";
+    //    }
+    //    else {
+    //        result += "        throw Errors.invalidOperation();\r\n";
+    //    }
+    //    result += "    }\r\n";
+    //}
+
 
     result += "    export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {\r\n";
     result += "        if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }\r\n";
-    result += "        switch (element.kind()) {\r\n";
+    result += "        return childAtArray[element.kind](element, index);\r\n";
+    //result += "        switch (element.kind) {\r\n";
 
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ": return " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(<" + definition.name + ">element, index);\r\n";
-    }
+    //for (var i = 0; i < definitions.length; i++) {
+    //    var definition = definitions[i];
+    //    result += "            case SyntaxKind." + getNameWithoutSuffix(definition) + ": return " + camelCase(getNameWithoutSuffix(definition)) + "ChildAt(<" + definition.name + ">element, index);\r\n";
+    //}
 
-    result += "        }\r\n";
+    //result += "        }\r\n";
+    result += "    }\r\n\r\n";
+
+    result += "    export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {\r\n";
+    result += "        return childAtArray[element.kind];\r\n";
     result += "    }\r\n";
 
+
     result += "}";
 
 
@@ -1566,6 +1628,7 @@ var walker = generateWalker();
 var scannerUtilities = generateScannerUtilities();
 var visitor = generateVisitor();
 var servicesUtilities = generateServicesUtilities();
+var utilities = generateUtilities();
 
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxInterfaces.generated.ts", syntaxInterfaces, false);
@@ -1573,3 +1636,4 @@ sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxWalker
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\scannerUtilities.generated.ts", scannerUtilities, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxVisitor.generated.ts", visitor, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxUtilities.generated.ts", servicesUtilities, false);
+sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\utilities.generated.ts", utilities, false);
diff --git a/src/services/syntax/syntaxList.ts b/src/services/syntax/syntaxList.ts
index dc880ea0fa0..235e3defd53 100644
--- a/src/services/syntax/syntaxList.ts
+++ b/src/services/syntax/syntaxList.ts
@@ -3,7 +3,7 @@
 interface Array<T> {
     __data: number;
 
-    kind(): TypeScript.SyntaxKind;
+    kind: TypeScript.SyntaxKind;
     parent: TypeScript.ISyntaxElement;
 }
 
@@ -36,18 +36,16 @@ module TypeScript {
 }
 
 module TypeScript.Syntax {
-    function addArrayFunction(name: string, func: Function) {
-        if (Object.defineProperty) {
-            Object.defineProperty(Array.prototype, name, { value: func, writable: true });
+    function addArrayPrototypeValue(name: string, val: any) {
+        if (Object.defineProperty && (<any>Array.prototype)[name] === undefined) {
+            Object.defineProperty(Array.prototype, name, { value: val, writable: false });
         }
         else {
-            (<any>Array.prototype)[name] = func;
+            (<any>Array.prototype)[name] = val;
         }
     }
 
-    addArrayFunction("kind", function () {
-        return SyntaxKind.List;
-    });
+    addArrayPrototypeValue("kind", SyntaxKind.List);
 
     export function list<T extends ISyntaxNodeOrToken>(nodes: T[]): T[] {
         for (var i = 0, n = nodes.length; i < n; i++) {
diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts
index f26ab254ea2..2dc2a86177c 100644
--- a/src/services/syntax/syntaxNodes.concrete.generated.ts
+++ b/src/services/syntax/syntaxNodes.concrete.generated.ts
@@ -6,633 +6,633 @@ module TypeScript {
         this.moduleElements = moduleElements, this.endOfFileToken = endOfFileToken;
         moduleElements.parent = this, endOfFileToken.parent = this;
     };
-    SourceUnitSyntax.prototype.kind = function() { return SyntaxKind.SourceUnit; }
+    SourceUnitSyntax.prototype.kind = SyntaxKind.SourceUnit;
 
     export var QualifiedNameSyntax: QualifiedNameConstructor = <any>function(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.left = left, this.dotToken = dotToken, this.right = right;
         left.parent = this, dotToken.parent = this, right.parent = this;
     };
-    QualifiedNameSyntax.prototype.kind = function() { return SyntaxKind.QualifiedName; }
+    QualifiedNameSyntax.prototype.kind = SyntaxKind.QualifiedName;
 
     export var ObjectTypeSyntax: ObjectTypeConstructor = <any>function(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>, closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openBraceToken = openBraceToken, this.typeMembers = typeMembers, this.closeBraceToken = closeBraceToken;
         openBraceToken.parent = this, typeMembers.parent = this, closeBraceToken.parent = this;
     };
-    ObjectTypeSyntax.prototype.kind = function() { return SyntaxKind.ObjectType; }
+    ObjectTypeSyntax.prototype.kind = SyntaxKind.ObjectType;
 
     export var FunctionTypeSyntax: FunctionTypeConstructor = <any>function(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) {
         if (data) { this.__data = data; }
         this.typeParameterList = typeParameterList, this.parameterList = parameterList, this.equalsGreaterThanToken = equalsGreaterThanToken, this.type = type;
         typeParameterList && (typeParameterList.parent = this), parameterList.parent = this, equalsGreaterThanToken.parent = this, type.parent = this;
     };
-    FunctionTypeSyntax.prototype.kind = function() { return SyntaxKind.FunctionType; }
+    FunctionTypeSyntax.prototype.kind = SyntaxKind.FunctionType;
 
     export var ArrayTypeSyntax: ArrayTypeConstructor = <any>function(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.type = type, this.openBracketToken = openBracketToken, this.closeBracketToken = closeBracketToken;
         type.parent = this, openBracketToken.parent = this, closeBracketToken.parent = this;
     };
-    ArrayTypeSyntax.prototype.kind = function() { return SyntaxKind.ArrayType; }
+    ArrayTypeSyntax.prototype.kind = SyntaxKind.ArrayType;
 
     export var ConstructorTypeSyntax: ConstructorTypeConstructor = <any>function(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax) {
         if (data) { this.__data = data; }
         this.newKeyword = newKeyword, this.typeParameterList = typeParameterList, this.parameterList = parameterList, this.equalsGreaterThanToken = equalsGreaterThanToken, this.type = type;
         newKeyword.parent = this, typeParameterList && (typeParameterList.parent = this), parameterList.parent = this, equalsGreaterThanToken.parent = this, type.parent = this;
     };
-    ConstructorTypeSyntax.prototype.kind = function() { return SyntaxKind.ConstructorType; }
+    ConstructorTypeSyntax.prototype.kind = SyntaxKind.ConstructorType;
 
     export var GenericTypeSyntax: GenericTypeConstructor = <any>function(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax) {
         if (data) { this.__data = data; }
         this.name = name, this.typeArgumentList = typeArgumentList;
         name.parent = this, typeArgumentList.parent = this;
     };
-    GenericTypeSyntax.prototype.kind = function() { return SyntaxKind.GenericType; }
+    GenericTypeSyntax.prototype.kind = SyntaxKind.GenericType;
 
     export var TypeQuerySyntax: TypeQueryConstructor = <any>function(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax) {
         if (data) { this.__data = data; }
         this.typeOfKeyword = typeOfKeyword, this.name = name;
         typeOfKeyword.parent = this, name.parent = this;
     };
-    TypeQuerySyntax.prototype.kind = function() { return SyntaxKind.TypeQuery; }
+    TypeQuerySyntax.prototype.kind = SyntaxKind.TypeQuery;
 
     export var TupleTypeSyntax: TupleTypeConstructor = <any>function(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList<ITypeSyntax>, closeBracketToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openBracketToken = openBracketToken, this.types = types, this.closeBracketToken = closeBracketToken;
         openBracketToken.parent = this, types.parent = this, closeBracketToken.parent = this;
     };
-    TupleTypeSyntax.prototype.kind = function() { return SyntaxKind.TupleType; }
+    TupleTypeSyntax.prototype.kind = SyntaxKind.TupleType;
 
     export var UnionTypeSyntax: UnionTypeConstructor = <any>function(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
         if (data) { this.__data = data; }
         this.left = left, this.barToken = barToken, this.right = right;
         left.parent = this, barToken.parent = this, right.parent = this;
     };
-    UnionTypeSyntax.prototype.kind = function() { return SyntaxKind.UnionType; }
+    UnionTypeSyntax.prototype.kind = SyntaxKind.UnionType;
 
     export var ParenthesizedTypeSyntax: ParenthesizedTypeConstructor = <any>function(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openParenToken = openParenToken, this.type = type, this.closeParenToken = closeParenToken;
         openParenToken.parent = this, type.parent = this, closeParenToken.parent = this;
     };
-    ParenthesizedTypeSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedType; }
+    ParenthesizedTypeSyntax.prototype.kind = SyntaxKind.ParenthesizedType;
 
     export var InterfaceDeclarationSyntax: InterfaceDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.interfaceKeyword = interfaceKeyword, this.identifier = identifier, this.typeParameterList = typeParameterList, this.heritageClauses = heritageClauses, this.body = body;
         modifiers.parent = this, interfaceKeyword.parent = this, identifier.parent = this, typeParameterList && (typeParameterList.parent = this), heritageClauses.parent = this, body.parent = this;
     };
-    InterfaceDeclarationSyntax.prototype.kind = function() { return SyntaxKind.InterfaceDeclaration; }
+    InterfaceDeclarationSyntax.prototype.kind = SyntaxKind.InterfaceDeclaration;
 
     export var FunctionDeclarationSyntax: FunctionDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.functionKeyword = functionKeyword, this.identifier = identifier, this.callSignature = callSignature, this.block = block, this.semicolonToken = semicolonToken;
         modifiers.parent = this, functionKeyword.parent = this, identifier.parent = this, callSignature.parent = this, block && (block.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    FunctionDeclarationSyntax.prototype.kind = function() { return SyntaxKind.FunctionDeclaration; }
+    FunctionDeclarationSyntax.prototype.kind = SyntaxKind.FunctionDeclaration;
 
     export var ModuleDeclarationSyntax: ModuleDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.moduleKeyword = moduleKeyword, this.name = name, this.stringLiteral = stringLiteral, this.openBraceToken = openBraceToken, this.moduleElements = moduleElements, this.closeBraceToken = closeBraceToken;
         modifiers.parent = this, moduleKeyword.parent = this, name && (name.parent = this), stringLiteral && (stringLiteral.parent = this), openBraceToken.parent = this, moduleElements.parent = this, closeBraceToken.parent = this;
     };
-    ModuleDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ModuleDeclaration; }
+    ModuleDeclarationSyntax.prototype.kind = SyntaxKind.ModuleDeclaration;
 
     export var ClassDeclarationSyntax: ClassDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.classKeyword = classKeyword, this.identifier = identifier, this.typeParameterList = typeParameterList, this.heritageClauses = heritageClauses, this.openBraceToken = openBraceToken, this.classElements = classElements, this.closeBraceToken = closeBraceToken;
         modifiers.parent = this, classKeyword.parent = this, identifier.parent = this, typeParameterList && (typeParameterList.parent = this), heritageClauses.parent = this, openBraceToken.parent = this, classElements.parent = this, closeBraceToken.parent = this;
     };
-    ClassDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ClassDeclaration; }
+    ClassDeclarationSyntax.prototype.kind = SyntaxKind.ClassDeclaration;
 
     export var EnumDeclarationSyntax: EnumDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList<EnumElementSyntax>, closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.enumKeyword = enumKeyword, this.identifier = identifier, this.openBraceToken = openBraceToken, this.enumElements = enumElements, this.closeBraceToken = closeBraceToken;
         modifiers.parent = this, enumKeyword.parent = this, identifier.parent = this, openBraceToken.parent = this, enumElements.parent = this, closeBraceToken.parent = this;
     };
-    EnumDeclarationSyntax.prototype.kind = function() { return SyntaxKind.EnumDeclaration; }
+    EnumDeclarationSyntax.prototype.kind = SyntaxKind.EnumDeclaration;
 
     export var ImportDeclarationSyntax: ImportDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.importKeyword = importKeyword, this.identifier = identifier, this.equalsToken = equalsToken, this.moduleReference = moduleReference, this.semicolonToken = semicolonToken;
         modifiers.parent = this, importKeyword.parent = this, identifier.parent = this, equalsToken.parent = this, moduleReference.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    ImportDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ImportDeclaration; }
+    ImportDeclarationSyntax.prototype.kind = SyntaxKind.ImportDeclaration;
 
     export var ExportAssignmentSyntax: ExportAssignmentConstructor = <any>function(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.exportKeyword = exportKeyword, this.equalsToken = equalsToken, this.identifier = identifier, this.semicolonToken = semicolonToken;
         exportKeyword.parent = this, equalsToken.parent = this, identifier.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    ExportAssignmentSyntax.prototype.kind = function() { return SyntaxKind.ExportAssignment; }
+    ExportAssignmentSyntax.prototype.kind = SyntaxKind.ExportAssignment;
 
     export var MemberFunctionDeclarationSyntax: MemberFunctionDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.propertyName = propertyName, this.callSignature = callSignature, this.block = block, this.semicolonToken = semicolonToken;
         modifiers.parent = this, propertyName.parent = this, callSignature.parent = this, block && (block.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    MemberFunctionDeclarationSyntax.prototype.kind = function() { return SyntaxKind.MemberFunctionDeclaration; }
+    MemberFunctionDeclarationSyntax.prototype.kind = SyntaxKind.MemberFunctionDeclaration;
 
     export var MemberVariableDeclarationSyntax: MemberVariableDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.variableDeclarator = variableDeclarator, this.semicolonToken = semicolonToken;
         modifiers.parent = this, variableDeclarator.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    MemberVariableDeclarationSyntax.prototype.kind = function() { return SyntaxKind.MemberVariableDeclaration; }
+    MemberVariableDeclarationSyntax.prototype.kind = SyntaxKind.MemberVariableDeclaration;
 
     export var ConstructorDeclarationSyntax: ConstructorDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.constructorKeyword = constructorKeyword, this.callSignature = callSignature, this.block = block, this.semicolonToken = semicolonToken;
         modifiers.parent = this, constructorKeyword.parent = this, callSignature.parent = this, block && (block.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    ConstructorDeclarationSyntax.prototype.kind = function() { return SyntaxKind.ConstructorDeclaration; }
+    ConstructorDeclarationSyntax.prototype.kind = SyntaxKind.ConstructorDeclaration;
 
     export var IndexMemberDeclarationSyntax: IndexMemberDeclarationConstructor = <any>function(data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.indexSignature = indexSignature, this.semicolonToken = semicolonToken;
         modifiers.parent = this, indexSignature.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    IndexMemberDeclarationSyntax.prototype.kind = function() { return SyntaxKind.IndexMemberDeclaration; }
+    IndexMemberDeclarationSyntax.prototype.kind = SyntaxKind.IndexMemberDeclaration;
 
     export var GetAccessorSyntax: GetAccessorConstructor = <any>function(data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.getKeyword = getKeyword, this.propertyName = propertyName, this.callSignature = callSignature, this.block = block;
         modifiers.parent = this, getKeyword.parent = this, propertyName.parent = this, callSignature.parent = this, block.parent = this;
     };
-    GetAccessorSyntax.prototype.kind = function() { return SyntaxKind.GetAccessor; }
+    GetAccessorSyntax.prototype.kind = SyntaxKind.GetAccessor;
 
     export var SetAccessorSyntax: SetAccessorConstructor = <any>function(data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.setKeyword = setKeyword, this.propertyName = propertyName, this.callSignature = callSignature, this.block = block;
         modifiers.parent = this, setKeyword.parent = this, propertyName.parent = this, callSignature.parent = this, block.parent = this;
     };
-    SetAccessorSyntax.prototype.kind = function() { return SyntaxKind.SetAccessor; }
+    SetAccessorSyntax.prototype.kind = SyntaxKind.SetAccessor;
 
     export var PropertySignatureSyntax: PropertySignatureConstructor = <any>function(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.questionToken = questionToken, this.typeAnnotation = typeAnnotation;
         propertyName.parent = this, questionToken && (questionToken.parent = this), typeAnnotation && (typeAnnotation.parent = this);
     };
-    PropertySignatureSyntax.prototype.kind = function() { return SyntaxKind.PropertySignature; }
+    PropertySignatureSyntax.prototype.kind = SyntaxKind.PropertySignature;
 
     export var CallSignatureSyntax: CallSignatureConstructor = <any>function(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax) {
         if (data) { this.__data = data; }
         this.typeParameterList = typeParameterList, this.parameterList = parameterList, this.typeAnnotation = typeAnnotation;
         typeParameterList && (typeParameterList.parent = this), parameterList.parent = this, typeAnnotation && (typeAnnotation.parent = this);
     };
-    CallSignatureSyntax.prototype.kind = function() { return SyntaxKind.CallSignature; }
+    CallSignatureSyntax.prototype.kind = SyntaxKind.CallSignature;
 
     export var ConstructSignatureSyntax: ConstructSignatureConstructor = <any>function(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax) {
         if (data) { this.__data = data; }
         this.newKeyword = newKeyword, this.callSignature = callSignature;
         newKeyword.parent = this, callSignature.parent = this;
     };
-    ConstructSignatureSyntax.prototype.kind = function() { return SyntaxKind.ConstructSignature; }
+    ConstructSignatureSyntax.prototype.kind = SyntaxKind.ConstructSignature;
 
     export var IndexSignatureSyntax: IndexSignatureConstructor = <any>function(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax) {
         if (data) { this.__data = data; }
         this.openBracketToken = openBracketToken, this.parameters = parameters, this.closeBracketToken = closeBracketToken, this.typeAnnotation = typeAnnotation;
         openBracketToken.parent = this, parameters.parent = this, closeBracketToken.parent = this, typeAnnotation && (typeAnnotation.parent = this);
     };
-    IndexSignatureSyntax.prototype.kind = function() { return SyntaxKind.IndexSignature; }
+    IndexSignatureSyntax.prototype.kind = SyntaxKind.IndexSignature;
 
     export var MethodSignatureSyntax: MethodSignatureConstructor = <any>function(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.questionToken = questionToken, this.callSignature = callSignature;
         propertyName.parent = this, questionToken && (questionToken.parent = this), callSignature.parent = this;
     };
-    MethodSignatureSyntax.prototype.kind = function() { return SyntaxKind.MethodSignature; }
+    MethodSignatureSyntax.prototype.kind = SyntaxKind.MethodSignature;
 
     export var BlockSyntax: BlockConstructor = <any>function(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openBraceToken = openBraceToken, this.statements = statements, this.closeBraceToken = closeBraceToken;
         openBraceToken.parent = this, statements.parent = this, closeBraceToken.parent = this;
     };
-    BlockSyntax.prototype.kind = function() { return SyntaxKind.Block; }
+    BlockSyntax.prototype.kind = SyntaxKind.Block;
 
     export var IfStatementSyntax: IfStatementConstructor = <any>function(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax) {
         if (data) { this.__data = data; }
         this.ifKeyword = ifKeyword, this.openParenToken = openParenToken, this.condition = condition, this.closeParenToken = closeParenToken, this.statement = statement, this.elseClause = elseClause;
         ifKeyword.parent = this, openParenToken.parent = this, condition.parent = this, closeParenToken.parent = this, statement.parent = this, elseClause && (elseClause.parent = this);
     };
-    IfStatementSyntax.prototype.kind = function() { return SyntaxKind.IfStatement; }
+    IfStatementSyntax.prototype.kind = SyntaxKind.IfStatement;
 
     export var VariableStatementSyntax: VariableStatementConstructor = <any>function(data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.modifiers = modifiers, this.variableDeclaration = variableDeclaration, this.semicolonToken = semicolonToken;
         modifiers.parent = this, variableDeclaration.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    VariableStatementSyntax.prototype.kind = function() { return SyntaxKind.VariableStatement; }
+    VariableStatementSyntax.prototype.kind = SyntaxKind.VariableStatement;
 
     export var ExpressionStatementSyntax: ExpressionStatementConstructor = <any>function(data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.expression = expression, this.semicolonToken = semicolonToken;
         expression.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    ExpressionStatementSyntax.prototype.kind = function() { return SyntaxKind.ExpressionStatement; }
+    ExpressionStatementSyntax.prototype.kind = SyntaxKind.ExpressionStatement;
 
     export var ReturnStatementSyntax: ReturnStatementConstructor = <any>function(data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.returnKeyword = returnKeyword, this.expression = expression, this.semicolonToken = semicolonToken;
         returnKeyword.parent = this, expression && (expression.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    ReturnStatementSyntax.prototype.kind = function() { return SyntaxKind.ReturnStatement; }
+    ReturnStatementSyntax.prototype.kind = SyntaxKind.ReturnStatement;
 
     export var SwitchStatementSyntax: SwitchStatementConstructor = <any>function(data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.switchKeyword = switchKeyword, this.openParenToken = openParenToken, this.expression = expression, this.closeParenToken = closeParenToken, this.openBraceToken = openBraceToken, this.switchClauses = switchClauses, this.closeBraceToken = closeBraceToken;
         switchKeyword.parent = this, openParenToken.parent = this, expression.parent = this, closeParenToken.parent = this, openBraceToken.parent = this, switchClauses.parent = this, closeBraceToken.parent = this;
     };
-    SwitchStatementSyntax.prototype.kind = function() { return SyntaxKind.SwitchStatement; }
+    SwitchStatementSyntax.prototype.kind = SyntaxKind.SwitchStatement;
 
     export var BreakStatementSyntax: BreakStatementConstructor = <any>function(data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.breakKeyword = breakKeyword, this.identifier = identifier, this.semicolonToken = semicolonToken;
         breakKeyword.parent = this, identifier && (identifier.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    BreakStatementSyntax.prototype.kind = function() { return SyntaxKind.BreakStatement; }
+    BreakStatementSyntax.prototype.kind = SyntaxKind.BreakStatement;
 
     export var ContinueStatementSyntax: ContinueStatementConstructor = <any>function(data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.continueKeyword = continueKeyword, this.identifier = identifier, this.semicolonToken = semicolonToken;
         continueKeyword.parent = this, identifier && (identifier.parent = this), semicolonToken && (semicolonToken.parent = this);
     };
-    ContinueStatementSyntax.prototype.kind = function() { return SyntaxKind.ContinueStatement; }
+    ContinueStatementSyntax.prototype.kind = SyntaxKind.ContinueStatement;
 
     export var ForStatementSyntax: ForStatementConstructor = <any>function(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.forKeyword = forKeyword, this.openParenToken = openParenToken, this.variableDeclaration = variableDeclaration, this.initializer = initializer, this.firstSemicolonToken = firstSemicolonToken, this.condition = condition, this.secondSemicolonToken = secondSemicolonToken, this.incrementor = incrementor, this.closeParenToken = closeParenToken, this.statement = statement;
         forKeyword.parent = this, openParenToken.parent = this, variableDeclaration && (variableDeclaration.parent = this), initializer && (initializer.parent = this), firstSemicolonToken.parent = this, condition && (condition.parent = this), secondSemicolonToken.parent = this, incrementor && (incrementor.parent = this), closeParenToken.parent = this, statement.parent = this;
     };
-    ForStatementSyntax.prototype.kind = function() { return SyntaxKind.ForStatement; }
+    ForStatementSyntax.prototype.kind = SyntaxKind.ForStatement;
 
     export var ForInStatementSyntax: ForInStatementConstructor = <any>function(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.forKeyword = forKeyword, this.openParenToken = openParenToken, this.variableDeclaration = variableDeclaration, this.left = left, this.inKeyword = inKeyword, this.expression = expression, this.closeParenToken = closeParenToken, this.statement = statement;
         forKeyword.parent = this, openParenToken.parent = this, variableDeclaration && (variableDeclaration.parent = this), left && (left.parent = this), inKeyword.parent = this, expression.parent = this, closeParenToken.parent = this, statement.parent = this;
     };
-    ForInStatementSyntax.prototype.kind = function() { return SyntaxKind.ForInStatement; }
+    ForInStatementSyntax.prototype.kind = SyntaxKind.ForInStatement;
 
     export var EmptyStatementSyntax: EmptyStatementConstructor = <any>function(data: number, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.semicolonToken = semicolonToken;
         semicolonToken.parent = this;
     };
-    EmptyStatementSyntax.prototype.kind = function() { return SyntaxKind.EmptyStatement; }
+    EmptyStatementSyntax.prototype.kind = SyntaxKind.EmptyStatement;
 
     export var ThrowStatementSyntax: ThrowStatementConstructor = <any>function(data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.throwKeyword = throwKeyword, this.expression = expression, this.semicolonToken = semicolonToken;
         throwKeyword.parent = this, expression.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    ThrowStatementSyntax.prototype.kind = function() { return SyntaxKind.ThrowStatement; }
+    ThrowStatementSyntax.prototype.kind = SyntaxKind.ThrowStatement;
 
     export var WhileStatementSyntax: WhileStatementConstructor = <any>function(data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.whileKeyword = whileKeyword, this.openParenToken = openParenToken, this.condition = condition, this.closeParenToken = closeParenToken, this.statement = statement;
         whileKeyword.parent = this, openParenToken.parent = this, condition.parent = this, closeParenToken.parent = this, statement.parent = this;
     };
-    WhileStatementSyntax.prototype.kind = function() { return SyntaxKind.WhileStatement; }
+    WhileStatementSyntax.prototype.kind = SyntaxKind.WhileStatement;
 
     export var TryStatementSyntax: TryStatementConstructor = <any>function(data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax) {
         if (data) { this.__data = data; }
         this.tryKeyword = tryKeyword, this.block = block, this.catchClause = catchClause, this.finallyClause = finallyClause;
         tryKeyword.parent = this, block.parent = this, catchClause && (catchClause.parent = this), finallyClause && (finallyClause.parent = this);
     };
-    TryStatementSyntax.prototype.kind = function() { return SyntaxKind.TryStatement; }
+    TryStatementSyntax.prototype.kind = SyntaxKind.TryStatement;
 
     export var LabeledStatementSyntax: LabeledStatementConstructor = <any>function(data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.identifier = identifier, this.colonToken = colonToken, this.statement = statement;
         identifier.parent = this, colonToken.parent = this, statement.parent = this;
     };
-    LabeledStatementSyntax.prototype.kind = function() { return SyntaxKind.LabeledStatement; }
+    LabeledStatementSyntax.prototype.kind = SyntaxKind.LabeledStatement;
 
     export var DoStatementSyntax: DoStatementConstructor = <any>function(data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.doKeyword = doKeyword, this.statement = statement, this.whileKeyword = whileKeyword, this.openParenToken = openParenToken, this.condition = condition, this.closeParenToken = closeParenToken, this.semicolonToken = semicolonToken;
         doKeyword.parent = this, statement.parent = this, whileKeyword.parent = this, openParenToken.parent = this, condition.parent = this, closeParenToken.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    DoStatementSyntax.prototype.kind = function() { return SyntaxKind.DoStatement; }
+    DoStatementSyntax.prototype.kind = SyntaxKind.DoStatement;
 
     export var DebuggerStatementSyntax: DebuggerStatementConstructor = <any>function(data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.debuggerKeyword = debuggerKeyword, this.semicolonToken = semicolonToken;
         debuggerKeyword.parent = this, semicolonToken && (semicolonToken.parent = this);
     };
-    DebuggerStatementSyntax.prototype.kind = function() { return SyntaxKind.DebuggerStatement; }
+    DebuggerStatementSyntax.prototype.kind = SyntaxKind.DebuggerStatement;
 
     export var WithStatementSyntax: WithStatementConstructor = <any>function(data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.withKeyword = withKeyword, this.openParenToken = openParenToken, this.condition = condition, this.closeParenToken = closeParenToken, this.statement = statement;
         withKeyword.parent = this, openParenToken.parent = this, condition.parent = this, closeParenToken.parent = this, statement.parent = this;
     };
-    WithStatementSyntax.prototype.kind = function() { return SyntaxKind.WithStatement; }
+    WithStatementSyntax.prototype.kind = SyntaxKind.WithStatement;
 
     export var PrefixUnaryExpressionSyntax: PrefixUnaryExpressionConstructor = <any>function(data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.operatorToken = operatorToken, this.operand = operand;
         operatorToken.parent = this, operand.parent = this;
     };
-    PrefixUnaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.PrefixUnaryExpression; }
+    PrefixUnaryExpressionSyntax.prototype.kind = SyntaxKind.PrefixUnaryExpression;
 
     export var DeleteExpressionSyntax: DeleteExpressionConstructor = <any>function(data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.deleteKeyword = deleteKeyword, this.expression = expression;
         deleteKeyword.parent = this, expression.parent = this;
     };
-    DeleteExpressionSyntax.prototype.kind = function() { return SyntaxKind.DeleteExpression; }
+    DeleteExpressionSyntax.prototype.kind = SyntaxKind.DeleteExpression;
 
     export var TypeOfExpressionSyntax: TypeOfExpressionConstructor = <any>function(data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.typeOfKeyword = typeOfKeyword, this.expression = expression;
         typeOfKeyword.parent = this, expression.parent = this;
     };
-    TypeOfExpressionSyntax.prototype.kind = function() { return SyntaxKind.TypeOfExpression; }
+    TypeOfExpressionSyntax.prototype.kind = SyntaxKind.TypeOfExpression;
 
     export var VoidExpressionSyntax: VoidExpressionConstructor = <any>function(data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.voidKeyword = voidKeyword, this.expression = expression;
         voidKeyword.parent = this, expression.parent = this;
     };
-    VoidExpressionSyntax.prototype.kind = function() { return SyntaxKind.VoidExpression; }
+    VoidExpressionSyntax.prototype.kind = SyntaxKind.VoidExpression;
 
     export var ConditionalExpressionSyntax: ConditionalExpressionConstructor = <any>function(data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.condition = condition, this.questionToken = questionToken, this.whenTrue = whenTrue, this.colonToken = colonToken, this.whenFalse = whenFalse;
         condition.parent = this, questionToken.parent = this, whenTrue.parent = this, colonToken.parent = this, whenFalse.parent = this;
     };
-    ConditionalExpressionSyntax.prototype.kind = function() { return SyntaxKind.ConditionalExpression; }
+    ConditionalExpressionSyntax.prototype.kind = SyntaxKind.ConditionalExpression;
 
     export var BinaryExpressionSyntax: BinaryExpressionConstructor = <any>function(data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.left = left, this.operatorToken = operatorToken, this.right = right;
         left.parent = this, operatorToken.parent = this, right.parent = this;
     };
-    BinaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.BinaryExpression; }
+    BinaryExpressionSyntax.prototype.kind = SyntaxKind.BinaryExpression;
 
     export var PostfixUnaryExpressionSyntax: PostfixUnaryExpressionConstructor = <any>function(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.operand = operand, this.operatorToken = operatorToken;
         operand.parent = this, operatorToken.parent = this;
     };
-    PostfixUnaryExpressionSyntax.prototype.kind = function() { return SyntaxKind.PostfixUnaryExpression; }
+    PostfixUnaryExpressionSyntax.prototype.kind = SyntaxKind.PostfixUnaryExpression;
 
     export var MemberAccessExpressionSyntax: MemberAccessExpressionConstructor = <any>function(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.expression = expression, this.dotToken = dotToken, this.name = name;
         expression.parent = this, dotToken.parent = this, name.parent = this;
     };
-    MemberAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.MemberAccessExpression; }
+    MemberAccessExpressionSyntax.prototype.kind = SyntaxKind.MemberAccessExpression;
 
     export var InvocationExpressionSyntax: InvocationExpressionConstructor = <any>function(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax) {
         if (data) { this.__data = data; }
         this.expression = expression, this.argumentList = argumentList;
         expression.parent = this, argumentList.parent = this;
     };
-    InvocationExpressionSyntax.prototype.kind = function() { return SyntaxKind.InvocationExpression; }
+    InvocationExpressionSyntax.prototype.kind = SyntaxKind.InvocationExpression;
 
     export var ArrayLiteralExpressionSyntax: ArrayLiteralExpressionConstructor = <any>function(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList<IExpressionSyntax>, closeBracketToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openBracketToken = openBracketToken, this.expressions = expressions, this.closeBracketToken = closeBracketToken;
         openBracketToken.parent = this, expressions.parent = this, closeBracketToken.parent = this;
     };
-    ArrayLiteralExpressionSyntax.prototype.kind = function() { return SyntaxKind.ArrayLiteralExpression; }
+    ArrayLiteralExpressionSyntax.prototype.kind = SyntaxKind.ArrayLiteralExpression;
 
     export var ObjectLiteralExpressionSyntax: ObjectLiteralExpressionConstructor = <any>function(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>, closeBraceToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openBraceToken = openBraceToken, this.propertyAssignments = propertyAssignments, this.closeBraceToken = closeBraceToken;
         openBraceToken.parent = this, propertyAssignments.parent = this, closeBraceToken.parent = this;
     };
-    ObjectLiteralExpressionSyntax.prototype.kind = function() { return SyntaxKind.ObjectLiteralExpression; }
+    ObjectLiteralExpressionSyntax.prototype.kind = SyntaxKind.ObjectLiteralExpression;
 
     export var ObjectCreationExpressionSyntax: ObjectCreationExpressionConstructor = <any>function(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax) {
         if (data) { this.__data = data; }
         this.newKeyword = newKeyword, this.expression = expression, this.argumentList = argumentList;
         newKeyword.parent = this, expression.parent = this, argumentList && (argumentList.parent = this);
     };
-    ObjectCreationExpressionSyntax.prototype.kind = function() { return SyntaxKind.ObjectCreationExpression; }
+    ObjectCreationExpressionSyntax.prototype.kind = SyntaxKind.ObjectCreationExpression;
 
     export var ParenthesizedExpressionSyntax: ParenthesizedExpressionConstructor = <any>function(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openParenToken = openParenToken, this.expression = expression, this.closeParenToken = closeParenToken;
         openParenToken.parent = this, expression.parent = this, closeParenToken.parent = this;
     };
-    ParenthesizedExpressionSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedExpression; }
+    ParenthesizedExpressionSyntax.prototype.kind = SyntaxKind.ParenthesizedExpression;
 
     export var ParenthesizedArrowFunctionExpressionSyntax: ParenthesizedArrowFunctionExpressionConstructor = <any>function(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.callSignature = callSignature, this.equalsGreaterThanToken = equalsGreaterThanToken, this.block = block, this.expression = expression;
         callSignature.parent = this, equalsGreaterThanToken.parent = this, block && (block.parent = this), expression && (expression.parent = this);
     };
-    ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = function() { return SyntaxKind.ParenthesizedArrowFunctionExpression; }
+    ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = SyntaxKind.ParenthesizedArrowFunctionExpression;
 
     export var SimpleArrowFunctionExpressionSyntax: SimpleArrowFunctionExpressionConstructor = <any>function(data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.parameter = parameter, this.equalsGreaterThanToken = equalsGreaterThanToken, this.block = block, this.expression = expression;
         parameter.parent = this, equalsGreaterThanToken.parent = this, block && (block.parent = this), expression && (expression.parent = this);
     };
-    SimpleArrowFunctionExpressionSyntax.prototype.kind = function() { return SyntaxKind.SimpleArrowFunctionExpression; }
+    SimpleArrowFunctionExpressionSyntax.prototype.kind = SyntaxKind.SimpleArrowFunctionExpression;
 
     export var CastExpressionSyntax: CastExpressionConstructor = <any>function(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.lessThanToken = lessThanToken, this.type = type, this.greaterThanToken = greaterThanToken, this.expression = expression;
         lessThanToken.parent = this, type.parent = this, greaterThanToken.parent = this, expression.parent = this;
     };
-    CastExpressionSyntax.prototype.kind = function() { return SyntaxKind.CastExpression; }
+    CastExpressionSyntax.prototype.kind = SyntaxKind.CastExpression;
 
     export var ElementAccessExpressionSyntax: ElementAccessExpressionConstructor = <any>function(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.expression = expression, this.openBracketToken = openBracketToken, this.argumentExpression = argumentExpression, this.closeBracketToken = closeBracketToken;
         expression.parent = this, openBracketToken.parent = this, argumentExpression.parent = this, closeBracketToken.parent = this;
     };
-    ElementAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.ElementAccessExpression; }
+    ElementAccessExpressionSyntax.prototype.kind = SyntaxKind.ElementAccessExpression;
 
     export var FunctionExpressionSyntax: FunctionExpressionConstructor = <any>function(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.functionKeyword = functionKeyword, this.identifier = identifier, this.callSignature = callSignature, this.block = block;
         functionKeyword.parent = this, identifier && (identifier.parent = this), callSignature.parent = this, block.parent = this;
     };
-    FunctionExpressionSyntax.prototype.kind = function() { return SyntaxKind.FunctionExpression; }
+    FunctionExpressionSyntax.prototype.kind = SyntaxKind.FunctionExpression;
 
     export var OmittedExpressionSyntax: OmittedExpressionConstructor = <any>function(data: number) {
         if (data) { this.__data = data; }
     };
-    OmittedExpressionSyntax.prototype.kind = function() { return SyntaxKind.OmittedExpression; }
+    OmittedExpressionSyntax.prototype.kind = SyntaxKind.OmittedExpression;
 
     export var TemplateExpressionSyntax: TemplateExpressionConstructor = <any>function(data: number, templateStartToken: ISyntaxToken, templateClauses: TemplateClauseSyntax[]) {
         if (data) { this.__data = data; }
         this.templateStartToken = templateStartToken, this.templateClauses = templateClauses;
         templateStartToken.parent = this, templateClauses.parent = this;
     };
-    TemplateExpressionSyntax.prototype.kind = function() { return SyntaxKind.TemplateExpression; }
+    TemplateExpressionSyntax.prototype.kind = SyntaxKind.TemplateExpression;
 
     export var TemplateAccessExpressionSyntax: TemplateAccessExpressionConstructor = <any>function(data: number, expression: ILeftHandSideExpressionSyntax, templateExpression: IPrimaryExpressionSyntax) {
         if (data) { this.__data = data; }
         this.expression = expression, this.templateExpression = templateExpression;
         expression.parent = this, templateExpression.parent = this;
     };
-    TemplateAccessExpressionSyntax.prototype.kind = function() { return SyntaxKind.TemplateAccessExpression; }
+    TemplateAccessExpressionSyntax.prototype.kind = SyntaxKind.TemplateAccessExpression;
 
     export var VariableDeclarationSyntax: VariableDeclarationConstructor = <any>function(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>) {
         if (data) { this.__data = data; }
         this.varKeyword = varKeyword, this.variableDeclarators = variableDeclarators;
         varKeyword.parent = this, variableDeclarators.parent = this;
     };
-    VariableDeclarationSyntax.prototype.kind = function() { return SyntaxKind.VariableDeclaration; }
+    VariableDeclarationSyntax.prototype.kind = SyntaxKind.VariableDeclaration;
 
     export var VariableDeclaratorSyntax: VariableDeclaratorConstructor = <any>function(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.typeAnnotation = typeAnnotation, this.equalsValueClause = equalsValueClause;
         propertyName.parent = this, typeAnnotation && (typeAnnotation.parent = this), equalsValueClause && (equalsValueClause.parent = this);
     };
-    VariableDeclaratorSyntax.prototype.kind = function() { return SyntaxKind.VariableDeclarator; }
+    VariableDeclaratorSyntax.prototype.kind = SyntaxKind.VariableDeclarator;
 
     export var ArgumentListSyntax: ArgumentListConstructor = <any>function(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, _arguments: ISeparatedSyntaxList<IExpressionSyntax>, closeParenToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.typeArgumentList = typeArgumentList, this.openParenToken = openParenToken, this.arguments = _arguments, this.closeParenToken = closeParenToken;
         typeArgumentList && (typeArgumentList.parent = this), openParenToken.parent = this, _arguments.parent = this, closeParenToken.parent = this;
     };
-    ArgumentListSyntax.prototype.kind = function() { return SyntaxKind.ArgumentList; }
+    ArgumentListSyntax.prototype.kind = SyntaxKind.ArgumentList;
 
     export var ParameterListSyntax: ParameterListConstructor = <any>function(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeParenToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.openParenToken = openParenToken, this.parameters = parameters, this.closeParenToken = closeParenToken;
         openParenToken.parent = this, parameters.parent = this, closeParenToken.parent = this;
     };
-    ParameterListSyntax.prototype.kind = function() { return SyntaxKind.ParameterList; }
+    ParameterListSyntax.prototype.kind = SyntaxKind.ParameterList;
 
     export var TypeArgumentListSyntax: TypeArgumentListConstructor = <any>function(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList<ITypeSyntax>, greaterThanToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.lessThanToken = lessThanToken, this.typeArguments = typeArguments, this.greaterThanToken = greaterThanToken;
         lessThanToken.parent = this, typeArguments.parent = this, greaterThanToken.parent = this;
     };
-    TypeArgumentListSyntax.prototype.kind = function() { return SyntaxKind.TypeArgumentList; }
+    TypeArgumentListSyntax.prototype.kind = SyntaxKind.TypeArgumentList;
 
     export var TypeParameterListSyntax: TypeParameterListConstructor = <any>function(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>, greaterThanToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.lessThanToken = lessThanToken, this.typeParameters = typeParameters, this.greaterThanToken = greaterThanToken;
         lessThanToken.parent = this, typeParameters.parent = this, greaterThanToken.parent = this;
     };
-    TypeParameterListSyntax.prototype.kind = function() { return SyntaxKind.TypeParameterList; }
+    TypeParameterListSyntax.prototype.kind = SyntaxKind.TypeParameterList;
 
     export var HeritageClauseSyntax: HeritageClauseConstructor = <any>function(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList<INameSyntax>) {
         if (data) { this.__data = data; }
         this.extendsOrImplementsKeyword = extendsOrImplementsKeyword, this.typeNames = typeNames;
         extendsOrImplementsKeyword.parent = this, typeNames.parent = this;
     };
-    HeritageClauseSyntax.prototype.kind = function() { return SyntaxKind.HeritageClause; }
+    HeritageClauseSyntax.prototype.kind = SyntaxKind.HeritageClause;
 
     export var EqualsValueClauseSyntax: EqualsValueClauseConstructor = <any>function(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.equalsToken = equalsToken, this.value = value;
         equalsToken.parent = this, value.parent = this;
     };
-    EqualsValueClauseSyntax.prototype.kind = function() { return SyntaxKind.EqualsValueClause; }
+    EqualsValueClauseSyntax.prototype.kind = SyntaxKind.EqualsValueClause;
 
     export var CaseSwitchClauseSyntax: CaseSwitchClauseConstructor = <any>function(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]) {
         if (data) { this.__data = data; }
         this.caseKeyword = caseKeyword, this.expression = expression, this.colonToken = colonToken, this.statements = statements;
         caseKeyword.parent = this, expression.parent = this, colonToken.parent = this, statements.parent = this;
     };
-    CaseSwitchClauseSyntax.prototype.kind = function() { return SyntaxKind.CaseSwitchClause; }
+    CaseSwitchClauseSyntax.prototype.kind = SyntaxKind.CaseSwitchClause;
 
     export var DefaultSwitchClauseSyntax: DefaultSwitchClauseConstructor = <any>function(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]) {
         if (data) { this.__data = data; }
         this.defaultKeyword = defaultKeyword, this.colonToken = colonToken, this.statements = statements;
         defaultKeyword.parent = this, colonToken.parent = this, statements.parent = this;
     };
-    DefaultSwitchClauseSyntax.prototype.kind = function() { return SyntaxKind.DefaultSwitchClause; }
+    DefaultSwitchClauseSyntax.prototype.kind = SyntaxKind.DefaultSwitchClause;
 
     export var ElseClauseSyntax: ElseClauseConstructor = <any>function(data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax) {
         if (data) { this.__data = data; }
         this.elseKeyword = elseKeyword, this.statement = statement;
         elseKeyword.parent = this, statement.parent = this;
     };
-    ElseClauseSyntax.prototype.kind = function() { return SyntaxKind.ElseClause; }
+    ElseClauseSyntax.prototype.kind = SyntaxKind.ElseClause;
 
     export var CatchClauseSyntax: CatchClauseConstructor = <any>function(data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.catchKeyword = catchKeyword, this.openParenToken = openParenToken, this.identifier = identifier, this.typeAnnotation = typeAnnotation, this.closeParenToken = closeParenToken, this.block = block;
         catchKeyword.parent = this, openParenToken.parent = this, identifier.parent = this, typeAnnotation && (typeAnnotation.parent = this), closeParenToken.parent = this, block.parent = this;
     };
-    CatchClauseSyntax.prototype.kind = function() { return SyntaxKind.CatchClause; }
+    CatchClauseSyntax.prototype.kind = SyntaxKind.CatchClause;
 
     export var FinallyClauseSyntax: FinallyClauseConstructor = <any>function(data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.finallyKeyword = finallyKeyword, this.block = block;
         finallyKeyword.parent = this, block.parent = this;
     };
-    FinallyClauseSyntax.prototype.kind = function() { return SyntaxKind.FinallyClause; }
+    FinallyClauseSyntax.prototype.kind = SyntaxKind.FinallyClause;
 
     export var TemplateClauseSyntax: TemplateClauseConstructor = <any>function(data: number, expression: IExpressionSyntax, templateMiddleOrEndToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.expression = expression, this.templateMiddleOrEndToken = templateMiddleOrEndToken;
         expression.parent = this, templateMiddleOrEndToken.parent = this;
     };
-    TemplateClauseSyntax.prototype.kind = function() { return SyntaxKind.TemplateClause; }
+    TemplateClauseSyntax.prototype.kind = SyntaxKind.TemplateClause;
 
     export var TypeParameterSyntax: TypeParameterConstructor = <any>function(data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax) {
         if (data) { this.__data = data; }
         this.identifier = identifier, this.constraint = constraint;
         identifier.parent = this, constraint && (constraint.parent = this);
     };
-    TypeParameterSyntax.prototype.kind = function() { return SyntaxKind.TypeParameter; }
+    TypeParameterSyntax.prototype.kind = SyntaxKind.TypeParameter;
 
     export var ConstraintSyntax: ConstraintConstructor = <any>function(data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken) {
         if (data) { this.__data = data; }
         this.extendsKeyword = extendsKeyword, this.typeOrExpression = typeOrExpression;
         extendsKeyword.parent = this, typeOrExpression.parent = this;
     };
-    ConstraintSyntax.prototype.kind = function() { return SyntaxKind.Constraint; }
+    ConstraintSyntax.prototype.kind = SyntaxKind.Constraint;
 
     export var SimplePropertyAssignmentSyntax: SimplePropertyAssignmentConstructor = <any>function(data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.colonToken = colonToken, this.expression = expression;
         propertyName.parent = this, colonToken.parent = this, expression.parent = this;
     };
-    SimplePropertyAssignmentSyntax.prototype.kind = function() { return SyntaxKind.SimplePropertyAssignment; }
+    SimplePropertyAssignmentSyntax.prototype.kind = SyntaxKind.SimplePropertyAssignment;
 
     export var FunctionPropertyAssignmentSyntax: FunctionPropertyAssignmentConstructor = <any>function(data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.callSignature = callSignature, this.block = block;
         propertyName.parent = this, callSignature.parent = this, block.parent = this;
     };
-    FunctionPropertyAssignmentSyntax.prototype.kind = function() { return SyntaxKind.FunctionPropertyAssignment; }
+    FunctionPropertyAssignmentSyntax.prototype.kind = SyntaxKind.FunctionPropertyAssignment;
 
     export var ParameterSyntax: ParameterConstructor = <any>function(data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax) {
         if (data) { this.__data = data; }
         this.dotDotDotToken = dotDotDotToken, this.modifiers = modifiers, this.identifier = identifier, this.questionToken = questionToken, this.typeAnnotation = typeAnnotation, this.equalsValueClause = equalsValueClause;
         dotDotDotToken && (dotDotDotToken.parent = this), modifiers.parent = this, identifier.parent = this, questionToken && (questionToken.parent = this), typeAnnotation && (typeAnnotation.parent = this), equalsValueClause && (equalsValueClause.parent = this);
     };
-    ParameterSyntax.prototype.kind = function() { return SyntaxKind.Parameter; }
+    ParameterSyntax.prototype.kind = SyntaxKind.Parameter;
 
     export var EnumElementSyntax: EnumElementConstructor = <any>function(data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax) {
         if (data) { this.__data = data; }
         this.propertyName = propertyName, this.equalsValueClause = equalsValueClause;
         propertyName.parent = this, equalsValueClause && (equalsValueClause.parent = this);
     };
-    EnumElementSyntax.prototype.kind = function() { return SyntaxKind.EnumElement; }
+    EnumElementSyntax.prototype.kind = SyntaxKind.EnumElement;
 
     export var TypeAnnotationSyntax: TypeAnnotationConstructor = <any>function(data: number, colonToken: ISyntaxToken, type: ITypeSyntax) {
         if (data) { this.__data = data; }
         this.colonToken = colonToken, this.type = type;
         colonToken.parent = this, type.parent = this;
     };
-    TypeAnnotationSyntax.prototype.kind = function() { return SyntaxKind.TypeAnnotation; }
+    TypeAnnotationSyntax.prototype.kind = SyntaxKind.TypeAnnotation;
 
     export var ExternalModuleReferenceSyntax: ExternalModuleReferenceConstructor = <any>function(data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken) {
         if (data) { this.__data = data; }
         this.requireKeyword = requireKeyword, this.openParenToken = openParenToken, this.stringLiteral = stringLiteral, this.closeParenToken = closeParenToken;
         requireKeyword.parent = this, openParenToken.parent = this, stringLiteral.parent = this, closeParenToken.parent = this;
     };
-    ExternalModuleReferenceSyntax.prototype.kind = function() { return SyntaxKind.ExternalModuleReference; }
+    ExternalModuleReferenceSyntax.prototype.kind = SyntaxKind.ExternalModuleReference;
 
     export var ModuleNameModuleReferenceSyntax: ModuleNameModuleReferenceConstructor = <any>function(data: number, moduleName: INameSyntax) {
         if (data) { this.__data = data; }
         this.moduleName = moduleName;
         moduleName.parent = this;
     };
-    ModuleNameModuleReferenceSyntax.prototype.kind = function() { return SyntaxKind.ModuleNameModuleReference; }
+    ModuleNameModuleReferenceSyntax.prototype.kind = SyntaxKind.ModuleNameModuleReference;
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxToken.ts b/src/services/syntax/syntaxToken.ts
index 876316bc995..12d543103a0 100644
--- a/src/services/syntax/syntaxToken.ts
+++ b/src/services/syntax/syntaxToken.ts
@@ -74,7 +74,7 @@ module TypeScript {
             return undefined;
         }
 
-        var kind = token.kind();
+        var kind = token.kind;
         var text = token.text();
 
         if (kind === SyntaxKind.IdentifierName) {
@@ -284,7 +284,7 @@ module TypeScript {
 
 module TypeScript.Syntax {
     export function realizeToken(token: ISyntaxToken, text: ISimpleText): ISyntaxToken {
-        return new RealizedToken(token.fullStart(), token.kind(), token.isKeywordConvertedToIdentifier(), token.leadingTrivia(text), token.text(), token.trailingTrivia(text));
+        return new RealizedToken(token.fullStart(), token.kind, token.isKeywordConvertedToIdentifier(), token.leadingTrivia(text), token.text(), token.trailingTrivia(text));
     }
 
     export function convertKeywordToIdentifier(token: ISyntaxToken): ISyntaxToken {
@@ -292,11 +292,11 @@ module TypeScript.Syntax {
     }
 
     export function withLeadingTrivia(token: ISyntaxToken, leadingTrivia: ISyntaxTriviaList, text: ISimpleText): ISyntaxToken {
-        return new RealizedToken(token.fullStart(), token.kind(), token.isKeywordConvertedToIdentifier(), leadingTrivia, token.text(), token.trailingTrivia(text));
+        return new RealizedToken(token.fullStart(), token.kind, token.isKeywordConvertedToIdentifier(), leadingTrivia, token.text(), token.trailingTrivia(text));
     }
 
     export function withTrailingTrivia(token: ISyntaxToken, trailingTrivia: ISyntaxTriviaList, text: ISimpleText): ISyntaxToken {
-        return new RealizedToken(token.fullStart(), token.kind(), token.isKeywordConvertedToIdentifier(), token.leadingTrivia(text), token.text(), trailingTrivia);
+        return new RealizedToken(token.fullStart(), token.kind, token.isKeywordConvertedToIdentifier(), token.leadingTrivia(text), token.text(), trailingTrivia);
     }
 
     export function emptyToken(kind: SyntaxKind): ISyntaxToken {
@@ -307,23 +307,19 @@ module TypeScript.Syntax {
         public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
         public parent: ISyntaxElement;
 
-        constructor(private _kind: SyntaxKind) {
+        constructor(public kind: SyntaxKind) {
         }
 
         public setFullStart(fullStart: number): void {
             // An empty token is always at the -1 position.
         }
 
-        public kind(): SyntaxKind {
-            return this._kind;
-        }
-
         public childCount() { return 0 }
         public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
         public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
 
         public clone(): ISyntaxToken {
-            return new EmptyToken(this.kind());
+            return new EmptyToken(this.kind);
         }
 
         // Empty tokens are never incrementally reusable.
@@ -363,7 +359,7 @@ module TypeScript.Syntax {
             while (true) {
                 var parent = current.parent;
                 if (parent === undefined) {
-                    Debug.assert(current.kind() === SyntaxKind.SourceUnit, "We had a node without a parent that was not the root node!");
+                    Debug.assert(current.kind === SyntaxKind.SourceUnit, "We had a node without a parent that was not the root node!");
 
                     // We walked all the way to the top, and never found a previous element.  This 
                     // can happen with code like:
@@ -422,7 +418,6 @@ module TypeScript.Syntax {
 
     class RealizedToken implements ISyntaxToken {
         private _fullStart: number;
-        private _kind: SyntaxKind;
         private _isKeywordConvertedToIdentifier: boolean;
         private _leadingTrivia: ISyntaxTriviaList;
         private _text: string;
@@ -432,13 +427,12 @@ module TypeScript.Syntax {
         public parent: ISyntaxElement;
 
         constructor(fullStart: number,
-            kind: SyntaxKind,
+            public kind: SyntaxKind,
             isKeywordConvertedToIdentifier: boolean,
             leadingTrivia: ISyntaxTriviaList,
             text: string,
             trailingTrivia: ISyntaxTriviaList) {
             this._fullStart = fullStart;
-            this._kind = kind;
             this._isKeywordConvertedToIdentifier = isKeywordConvertedToIdentifier;
             this._text = text;
 
@@ -458,16 +452,12 @@ module TypeScript.Syntax {
             this._fullStart = fullStart;
         }
 
-        public kind(): SyntaxKind {
-            return this._kind;
-        }
-        
         public childCount() { return 0 }
         public childAt(index: number): ISyntaxElement { throw Errors.invalidOperation() }
         public accept(visitor: ISyntaxVisitor): any { return visitor.visitToken(this) }
 
         public clone(): ISyntaxToken {
-            return new RealizedToken(this._fullStart, this.kind(), this._isKeywordConvertedToIdentifier, this._leadingTrivia, this._text, this._trailingTrivia);
+            return new RealizedToken(this._fullStart, this.kind, this._isKeywordConvertedToIdentifier, this._leadingTrivia, this._text, this._trailingTrivia);
         }
 
         // Realized tokens are created from the parser.  They are *never* incrementally reusable.
@@ -500,14 +490,11 @@ module TypeScript.Syntax {
     class ConvertedKeywordToken implements ISyntaxToken {
         public _primaryExpressionBrand: any; public _memberExpressionBrand: any; public _leftHandSideExpressionBrand: any; public _postfixExpressionBrand: any; public _unaryExpressionBrand: any; public _expressionBrand: any; public _typeBrand: any; public _syntaxNodeOrTokenBrand: any;
         public parent: ISyntaxElement;
+        public kind: SyntaxKind;
 
         constructor(private underlyingToken: ISyntaxToken) {
         }
 
-        public kind() {
-            return SyntaxKind.IdentifierName;
-        }
-
         public setFullStart(fullStart: number): void {
             this.underlyingToken.setFullStart(fullStart);
         }
@@ -594,4 +581,5 @@ module TypeScript.Syntax {
             return new ConvertedKeywordToken(this.underlyingToken);
         }
     }
+    ConvertedKeywordToken.prototype.kind = SyntaxKind.IdentifierName;
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxTree.ts b/src/services/syntax/syntaxTree.ts
index d466bd7df82..a61d3707a46 100644
--- a/src/services/syntax/syntaxTree.ts
+++ b/src/services/syntax/syntaxTree.ts
@@ -231,7 +231,7 @@ module TypeScript {
         }
 
         private checkParameterAccessibilityModifier(parameterList: ParameterListSyntax, modifier: ISyntaxToken, modifierIndex: number): boolean {
-            if (!SyntaxFacts.isAccessibilityModifier(modifier.kind())) {
+            if (!SyntaxFacts.isAccessibilityModifier(modifier.kind)) {
                 this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]);
                 return true;
             }
@@ -280,7 +280,7 @@ module TypeScript {
 
         public visitHeritageClause(node: HeritageClauseSyntax): void {
             if (this.checkForTrailingComma(node.typeNames) ||
-                this.checkForAtLeastOneElement(node.typeNames, node.extendsOrImplementsKeyword, SyntaxFacts.getText(node.extendsOrImplementsKeyword.kind()))) {
+                this.checkForAtLeastOneElement(node.typeNames, node.extendsOrImplementsKeyword, SyntaxFacts.getText(node.extendsOrImplementsKeyword.kind))) {
                 return;
             }
 
@@ -359,8 +359,8 @@ module TypeScript {
                 this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation);
                 return true;
             }
-            else if (parameter.typeAnnotation.type.kind() !== SyntaxKind.StringKeyword &&
-                     parameter.typeAnnotation.type.kind() !== SyntaxKind.NumberKeyword) {
+            else if (parameter.typeAnnotation.type.kind !== SyntaxKind.StringKeyword &&
+                     parameter.typeAnnotation.type.kind !== SyntaxKind.NumberKeyword) {
                 this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number);
                 return true;
             }
@@ -389,7 +389,7 @@ module TypeScript {
                 Debug.assert(i <= 2);
                 var heritageClause = node.heritageClauses[i];
 
-                if (heritageClause.extendsOrImplementsKeyword.kind() === SyntaxKind.ExtendsKeyword) {
+                if (heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ExtendsKeyword) {
                     if (seenExtendsClause) {
                         this.pushDiagnostic(heritageClause, DiagnosticCode.extends_clause_already_seen);
                         return true;
@@ -408,7 +408,7 @@ module TypeScript {
                     seenExtendsClause = true;
                 }
                 else {
-                    Debug.assert(heritageClause.extendsOrImplementsKeyword.kind() === SyntaxKind.ImplementsKeyword);
+                    Debug.assert(heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ImplementsKeyword);
                     if (seenImplementsClause) {
                         this.pushDiagnostic(heritageClause, DiagnosticCode.implements_clause_already_seen);
                         return true;
@@ -468,7 +468,7 @@ module TypeScript {
                 Debug.assert(i <= 1);
                 var heritageClause = node.heritageClauses[i];
 
-                if (heritageClause.extendsOrImplementsKeyword.kind() === SyntaxKind.ExtendsKeyword) {
+                if (heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ExtendsKeyword) {
                     if (seenExtendsClause) {
                         this.pushDiagnostic(heritageClause, DiagnosticCode.extends_clause_already_seen);
                         return true;
@@ -477,7 +477,7 @@ module TypeScript {
                     seenExtendsClause = true;
                 }
                 else {
-                    Debug.assert(heritageClause.extendsOrImplementsKeyword.kind() === SyntaxKind.ImplementsKeyword);
+                    Debug.assert(heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ImplementsKeyword);
                     this.pushDiagnostic(heritageClause, DiagnosticCode.Interface_declaration_cannot_have_implements_clause);
                     return true;
                 }
@@ -489,7 +489,7 @@ module TypeScript {
         private checkInterfaceModifiers(modifiers: ISyntaxToken[]): boolean {
             for (var i = 0, n = modifiers.length; i < n; i++) {
                 var modifier = modifiers[i];
-                if (modifier.kind() === SyntaxKind.DeclareKeyword) {
+                if (modifier.kind === SyntaxKind.DeclareKeyword) {
                     this.pushDiagnostic(modifier,
                         DiagnosticCode.A_declare_modifier_cannot_be_used_with_an_interface_declaration);
                     return true;
@@ -516,7 +516,7 @@ module TypeScript {
 
             for (var i = 0, n = list.length; i < n; i++) {
                 var modifier = list[i];
-                if (SyntaxFacts.isAccessibilityModifier(modifier.kind())) {
+                if (SyntaxFacts.isAccessibilityModifier(modifier.kind)) {
                     if (seenAccessibilityModifier) {
                         this.pushDiagnostic(modifier, DiagnosticCode.Accessibility_modifier_already_seen);
                         return true;
@@ -530,7 +530,7 @@ module TypeScript {
 
                     seenAccessibilityModifier = true;
                 }
-                else if (modifier.kind() === SyntaxKind.StaticKeyword) {
+                else if (modifier.kind === SyntaxKind.StaticKeyword) {
                     if (seenStaticModifier) {
                         this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
                         return true;
@@ -763,7 +763,7 @@ module TypeScript {
         }
 
         public visitInvocationExpression(node: InvocationExpressionSyntax): void {
-            if (node.expression.kind() === SyntaxKind.SuperKeyword &&
+            if (node.expression.kind === SyntaxKind.SuperKeyword &&
                 node.argumentList.typeArgumentList) {
                 this.pushDiagnostic(node, DiagnosticCode.super_invocation_cannot_have_type_arguments);
             }
@@ -777,13 +777,13 @@ module TypeScript {
 
             for (var i = 0, n = modifiers.length; i < n; i++) {
                 var modifier = modifiers[i];
-                if (SyntaxFacts.isAccessibilityModifier(modifier.kind()) ||
-                    modifier.kind() === SyntaxKind.StaticKeyword) {
+                if (SyntaxFacts.isAccessibilityModifier(modifier.kind) ||
+                    modifier.kind === SyntaxKind.StaticKeyword) {
                     this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_module_element, [modifier.text()]);
                     return true;
                 }
 
-                if (modifier.kind() === SyntaxKind.DeclareKeyword) {
+                if (modifier.kind === SyntaxKind.DeclareKeyword) {
                     if (seenDeclareModifier) {
                         this.pushDiagnostic(modifier, DiagnosticCode.Accessibility_modifier_already_seen);
                         return;
@@ -791,7 +791,7 @@ module TypeScript {
 
                     seenDeclareModifier = true;
                 }
-                else if (modifier.kind() === SyntaxKind.ExportKeyword) {
+                else if (modifier.kind === SyntaxKind.ExportKeyword) {
                     if (seenExportModifier) {
                         this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_already_seen, [modifier.text()]);
                         return;
@@ -814,9 +814,9 @@ module TypeScript {
             if (!node.stringLiteral) {
                 for (var i = 0, n = node.moduleElements.length; i < n; i++) {
                     var child = node.moduleElements[i];
-                    if (child.kind() === SyntaxKind.ImportDeclaration) {
+                    if (child.kind === SyntaxKind.ImportDeclaration) {
                         var importDeclaration = <ImportDeclarationSyntax>child;
-                        if (importDeclaration.moduleReference.kind() === SyntaxKind.ExternalModuleReference) {
+                        if (importDeclaration.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
                             this.pushDiagnostic(importDeclaration, DiagnosticCode.Import_declarations_in_an_internal_module_cannot_reference_an_external_module);
                         }
                     }
@@ -874,7 +874,7 @@ module TypeScript {
             for (var i = 0, n = node.moduleElements.length; i < n; i++) {
                 var child = node.moduleElements[i];
 
-                if (child.kind() === SyntaxKind.ExportAssignment) {
+                if (child.kind === SyntaxKind.ExportAssignment) {
                     this.pushDiagnostic(child, DiagnosticCode.Export_assignment_cannot_be_used_in_internal_modules);
                     return true;
                 }
@@ -898,7 +898,7 @@ module TypeScript {
             if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) {
                 // Provide a specialized message for a block as a statement versus the block as a 
                 // function body.
-                if (node.parent.kind() === SyntaxKind.List) {
+                if (node.parent.kind === SyntaxKind.List) {
                     this.pushDiagnostic(firstToken(node), DiagnosticCode.Statements_are_not_allowed_in_ambient_contexts);
                 }
                 else {
@@ -979,7 +979,7 @@ module TypeScript {
 
         private inSwitchStatement(ast: ISyntaxElement): boolean {
             while (ast) {
-                if (ast.kind() === SyntaxKind.SwitchStatement) {
+                if (ast.kind === SyntaxKind.SwitchStatement) {
                     return true;
                 }
 
@@ -994,7 +994,7 @@ module TypeScript {
         }
 
         private isIterationStatement(ast: ISyntaxElement): boolean {
-            switch (ast.kind()) {
+            switch (ast.kind) {
                 case SyntaxKind.ForStatement:
                 case SyntaxKind.ForInStatement:
                 case SyntaxKind.WhileStatement:
@@ -1026,7 +1026,7 @@ module TypeScript {
 
             element = element.parent;
             while (element) {
-                if (element.kind() === SyntaxKind.LabeledStatement) {
+                if (element.kind === SyntaxKind.LabeledStatement) {
                     var labeledStatement = <LabeledStatementSyntax>element;
                     if (breakable) {
                         // Breakable labels can be placed on any construct
@@ -1052,7 +1052,7 @@ module TypeScript {
         }
 
         private labelIsOnContinuableConstruct(statement: ISyntaxElement): boolean {
-            switch (statement.kind()) {
+            switch (statement.kind) {
                 case SyntaxKind.LabeledStatement:
                     // Labels work transitively.  i.e. if you have:
                     //      foo:
@@ -1363,7 +1363,7 @@ module TypeScript {
         private checkListSeparators<T extends ISyntaxNodeOrToken>(list: ISeparatedSyntaxList<T>, kind: SyntaxKind): boolean {
             for (var i = 0, n = separatorCount(list); i < n; i++) {
                 var child = separatorAt(list, i);
-                if (child.kind() !== kind) {
+                if (child.kind !== kind) {
                     this.pushDiagnostic(child, DiagnosticCode._0_expected, [SyntaxFacts.getText(kind)]);
                 }
             }
@@ -1418,7 +1418,7 @@ module TypeScript {
         }
 
         private checkForTemplatePropertyName(token: ISyntaxToken): boolean {
-            if (token.kind() === SyntaxKind.NoSubstitutionTemplateToken) {
+            if (token.kind === SyntaxKind.NoSubstitutionTemplateToken) {
                 this.pushDiagnostic(token, DiagnosticCode.Template_literal_cannot_be_used_as_an_element_name);
                 return true;
             }
@@ -1427,7 +1427,7 @@ module TypeScript {
         }
 
         private checkVariableDeclaratorIdentifier(node: VariableDeclaratorSyntax): boolean {
-            if (node.parent.kind() !== SyntaxKind.MemberVariableDeclaration) {
+            if (node.parent.kind !== SyntaxKind.MemberVariableDeclaration) {
                 if (this.checkForDisallowedEvalOrArguments(node, node.propertyName)) {
                     return true;
                 }
@@ -1460,8 +1460,8 @@ module TypeScript {
         private checkConstructorModifiers(modifiers: ISyntaxToken[]): boolean {
             for (var i = 0, n = modifiers.length; i < n; i++) {
                 var child = modifiers[i];
-                if (child.kind() !== SyntaxKind.PublicKeyword) {
-                    this.pushDiagnostic(child, DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [SyntaxFacts.getText(child.kind())]);
+                if (child.kind !== SyntaxKind.PublicKeyword) {
+                    this.pushDiagnostic(child, DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [SyntaxFacts.getText(child.kind)]);
                     return true;
                 }
             }
@@ -1531,7 +1531,7 @@ module TypeScript {
         }
 
         private isPreIncrementOrDecrementExpression(node: PrefixUnaryExpressionSyntax) {
-            switch (node.operatorToken.kind()) {
+            switch (node.operatorToken.kind) {
                 case SyntaxKind.MinusMinusToken:
                 case SyntaxKind.PlusPlusToken:
                     return true;
@@ -1541,7 +1541,7 @@ module TypeScript {
         }
 
         public visitDeleteExpression(node: DeleteExpressionSyntax): void {
-            if (parsedInStrictMode(node) && node.expression.kind() === SyntaxKind.IdentifierName) {
+            if (parsedInStrictMode(node) && node.expression.kind === SyntaxKind.IdentifierName) {
                 this.pushDiagnostic(firstToken(node), DiagnosticCode.delete_cannot_be_called_on_an_identifier_in_strict_mode);
                 return;
             }
@@ -1550,7 +1550,7 @@ module TypeScript {
         }
 
         private checkIllegalAssignment(node: BinaryExpressionSyntax): boolean {
-            if (parsedInStrictMode(node) && SyntaxFacts.isAssignmentOperatorToken(node.operatorToken.kind()) && this.isEvalOrArguments(node.left)) {
+            if (parsedInStrictMode(node) && SyntaxFacts.isAssignmentOperatorToken(node.operatorToken.kind) && this.isEvalOrArguments(node.left)) {
                 this.pushDiagnostic(node.operatorToken, DiagnosticCode.Invalid_use_of_0_in_strict_mode, [this.getEvalOrArguments(node.left)]);
                 return true;
             }
@@ -1559,7 +1559,7 @@ module TypeScript {
         }
 
         private getEvalOrArguments(expr: IExpressionSyntax): string {
-            if (expr.kind() === SyntaxKind.IdentifierName) {
+            if (expr.kind === SyntaxKind.IdentifierName) {
                 var text = tokenValueText(<ISyntaxToken>expr);
                 if (text === "eval" || text === "arguments") {
                     return text;
@@ -1582,7 +1582,7 @@ module TypeScript {
         }
 
         private checkConstraintType(node: ConstraintSyntax): boolean {
-            if (!SyntaxFacts.isType(node.typeOrExpression.kind())) {
+            if (!SyntaxFacts.isType(node.typeOrExpression.kind)) {
                 this.pushDiagnostic(node.typeOrExpression, DiagnosticCode.Type_expected);
                 return true;
             }
@@ -1639,13 +1639,13 @@ module TypeScript {
             var moduleElement = node.moduleElements[i];
 
             var _firstToken = firstToken(moduleElement);
-            if (_firstToken && _firstToken.kind() === SyntaxKind.ExportKeyword) {
+            if (_firstToken && _firstToken.kind === SyntaxKind.ExportKeyword) {
                 return new TextSpan(start(_firstToken), width(_firstToken));
             }
 
-            if (moduleElement.kind() === SyntaxKind.ImportDeclaration) {
+            if (moduleElement.kind === SyntaxKind.ImportDeclaration) {
                 var importDecl = <ImportDeclarationSyntax>moduleElement;
-                if (importDecl.moduleReference.kind() === SyntaxKind.ExternalModuleReference) {
+                if (importDecl.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
                     var literal = (<TypeScript.ExternalModuleReferenceSyntax>importDecl.moduleReference).stringLiteral;
                     return new TextSpan(start(literal), width(literal));
                 }
diff --git a/src/services/syntax/syntaxUtilities.generated.ts b/src/services/syntax/syntaxUtilities.generated.ts
index a32cfcf9a53..17152889f5c 100644
--- a/src/services/syntax/syntaxUtilities.generated.ts
+++ b/src/services/syntax/syntaxUtilities.generated.ts
@@ -3,786 +3,701 @@ module TypeScript {
 
     export function childCount(element: ISyntaxElement): number {
         if (isList(element)) { return (<ISyntaxNodeOrToken[]>element).length; }
-        return childCountArray[element.kind()];
+        return childCountArray[element.kind];
     }
 
-    function sourceUnitChildAt(node: SourceUnitSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.moduleElements;
-            case 1: return node.endOfFileToken;
-        }
-    }
-    function qualifiedNameChildAt(node: QualifiedNameSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.left;
-            case 1: return node.dotToken;
-            case 2: return node.right;
-        }
-    }
-    function objectTypeChildAt(node: ObjectTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBraceToken;
-            case 1: return node.typeMembers;
-            case 2: return node.closeBraceToken;
-        }
-    }
-    function functionTypeChildAt(node: FunctionTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.typeParameterList;
-            case 1: return node.parameterList;
-            case 2: return node.equalsGreaterThanToken;
-            case 3: return node.type;
-        }
-    }
-    function arrayTypeChildAt(node: ArrayTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.type;
-            case 1: return node.openBracketToken;
-            case 2: return node.closeBracketToken;
-        }
-    }
-    function constructorTypeChildAt(node: ConstructorTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.newKeyword;
-            case 1: return node.typeParameterList;
-            case 2: return node.parameterList;
-            case 3: return node.equalsGreaterThanToken;
-            case 4: return node.type;
-        }
-    }
-    function genericTypeChildAt(node: GenericTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.name;
-            case 1: return node.typeArgumentList;
-        }
-    }
-    function typeQueryChildAt(node: TypeQuerySyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.typeOfKeyword;
-            case 1: return node.name;
-        }
-    }
-    function tupleTypeChildAt(node: TupleTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBracketToken;
-            case 1: return node.types;
-            case 2: return node.closeBracketToken;
-        }
-    }
-    function unionTypeChildAt(node: UnionTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.left;
-            case 1: return node.barToken;
-            case 2: return node.right;
-        }
-    }
-    function parenthesizedTypeChildAt(node: ParenthesizedTypeSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openParenToken;
-            case 1: return node.type;
-            case 2: return node.closeParenToken;
-        }
-    }
-    function interfaceDeclarationChildAt(node: InterfaceDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.interfaceKeyword;
-            case 2: return node.identifier;
-            case 3: return node.typeParameterList;
-            case 4: return node.heritageClauses;
-            case 5: return node.body;
-        }
-    }
-    function functionDeclarationChildAt(node: FunctionDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.functionKeyword;
-            case 2: return node.identifier;
-            case 3: return node.callSignature;
-            case 4: return node.block;
-            case 5: return node.semicolonToken;
-        }
-    }
-    function moduleDeclarationChildAt(node: ModuleDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.moduleKeyword;
-            case 2: return node.name;
-            case 3: return node.stringLiteral;
-            case 4: return node.openBraceToken;
-            case 5: return node.moduleElements;
-            case 6: return node.closeBraceToken;
-        }
-    }
-    function classDeclarationChildAt(node: ClassDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.classKeyword;
-            case 2: return node.identifier;
-            case 3: return node.typeParameterList;
-            case 4: return node.heritageClauses;
-            case 5: return node.openBraceToken;
-            case 6: return node.classElements;
-            case 7: return node.closeBraceToken;
-        }
-    }
-    function enumDeclarationChildAt(node: EnumDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.enumKeyword;
-            case 2: return node.identifier;
-            case 3: return node.openBraceToken;
-            case 4: return node.enumElements;
-            case 5: return node.closeBraceToken;
-        }
-    }
-    function importDeclarationChildAt(node: ImportDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.importKeyword;
-            case 2: return node.identifier;
-            case 3: return node.equalsToken;
-            case 4: return node.moduleReference;
-            case 5: return node.semicolonToken;
-        }
-    }
-    function exportAssignmentChildAt(node: ExportAssignmentSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.exportKeyword;
-            case 1: return node.equalsToken;
-            case 2: return node.identifier;
-            case 3: return node.semicolonToken;
-        }
-    }
-    function memberFunctionDeclarationChildAt(node: MemberFunctionDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.propertyName;
-            case 2: return node.callSignature;
-            case 3: return node.block;
-            case 4: return node.semicolonToken;
-        }
-    }
-    function memberVariableDeclarationChildAt(node: MemberVariableDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.variableDeclarator;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function constructorDeclarationChildAt(node: ConstructorDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.constructorKeyword;
-            case 2: return node.callSignature;
-            case 3: return node.block;
-            case 4: return node.semicolonToken;
-        }
-    }
-    function indexMemberDeclarationChildAt(node: IndexMemberDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.indexSignature;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function getAccessorChildAt(node: GetAccessorSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.getKeyword;
-            case 2: return node.propertyName;
-            case 3: return node.callSignature;
-            case 4: return node.block;
-        }
-    }
-    function setAccessorChildAt(node: SetAccessorSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.setKeyword;
-            case 2: return node.propertyName;
-            case 3: return node.callSignature;
-            case 4: return node.block;
-        }
-    }
-    function propertySignatureChildAt(node: PropertySignatureSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.questionToken;
-            case 2: return node.typeAnnotation;
-        }
-    }
-    function callSignatureChildAt(node: CallSignatureSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.typeParameterList;
-            case 1: return node.parameterList;
-            case 2: return node.typeAnnotation;
-        }
-    }
-    function constructSignatureChildAt(node: ConstructSignatureSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.newKeyword;
-            case 1: return node.callSignature;
-        }
-    }
-    function indexSignatureChildAt(node: IndexSignatureSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBracketToken;
-            case 1: return node.parameters;
-            case 2: return node.closeBracketToken;
-            case 3: return node.typeAnnotation;
-        }
-    }
-    function methodSignatureChildAt(node: MethodSignatureSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.questionToken;
-            case 2: return node.callSignature;
-        }
-    }
-    function blockChildAt(node: BlockSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBraceToken;
-            case 1: return node.statements;
-            case 2: return node.closeBraceToken;
-        }
-    }
-    function ifStatementChildAt(node: IfStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.ifKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.condition;
-            case 3: return node.closeParenToken;
-            case 4: return node.statement;
-            case 5: return node.elseClause;
-        }
-    }
-    function variableStatementChildAt(node: VariableStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.modifiers;
-            case 1: return node.variableDeclaration;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function expressionStatementChildAt(node: ExpressionStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.semicolonToken;
-        }
-    }
-    function returnStatementChildAt(node: ReturnStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.returnKeyword;
-            case 1: return node.expression;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function switchStatementChildAt(node: SwitchStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.switchKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.expression;
-            case 3: return node.closeParenToken;
-            case 4: return node.openBraceToken;
-            case 5: return node.switchClauses;
-            case 6: return node.closeBraceToken;
-        }
-    }
-    function breakStatementChildAt(node: BreakStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.breakKeyword;
-            case 1: return node.identifier;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function continueStatementChildAt(node: ContinueStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.continueKeyword;
-            case 1: return node.identifier;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function forStatementChildAt(node: ForStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.forKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.variableDeclaration;
-            case 3: return node.initializer;
-            case 4: return node.firstSemicolonToken;
-            case 5: return node.condition;
-            case 6: return node.secondSemicolonToken;
-            case 7: return node.incrementor;
-            case 8: return node.closeParenToken;
-            case 9: return node.statement;
-        }
-    }
-    function forInStatementChildAt(node: ForInStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.forKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.variableDeclaration;
-            case 3: return node.left;
-            case 4: return node.inKeyword;
-            case 5: return node.expression;
-            case 6: return node.closeParenToken;
-            case 7: return node.statement;
-        }
-    }
-    function emptyStatementChildAt(node: EmptyStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.semicolonToken;
-        }
-    }
-    function throwStatementChildAt(node: ThrowStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.throwKeyword;
-            case 1: return node.expression;
-            case 2: return node.semicolonToken;
-        }
-    }
-    function whileStatementChildAt(node: WhileStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.whileKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.condition;
-            case 3: return node.closeParenToken;
-            case 4: return node.statement;
-        }
-    }
-    function tryStatementChildAt(node: TryStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.tryKeyword;
-            case 1: return node.block;
-            case 2: return node.catchClause;
-            case 3: return node.finallyClause;
-        }
-    }
-    function labeledStatementChildAt(node: LabeledStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.identifier;
-            case 1: return node.colonToken;
-            case 2: return node.statement;
-        }
-    }
-    function doStatementChildAt(node: DoStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.doKeyword;
-            case 1: return node.statement;
-            case 2: return node.whileKeyword;
-            case 3: return node.openParenToken;
-            case 4: return node.condition;
-            case 5: return node.closeParenToken;
-            case 6: return node.semicolonToken;
-        }
-    }
-    function debuggerStatementChildAt(node: DebuggerStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.debuggerKeyword;
-            case 1: return node.semicolonToken;
-        }
-    }
-    function withStatementChildAt(node: WithStatementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.withKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.condition;
-            case 3: return node.closeParenToken;
-            case 4: return node.statement;
-        }
-    }
-    function prefixUnaryExpressionChildAt(node: PrefixUnaryExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.operatorToken;
-            case 1: return node.operand;
-        }
-    }
-    function deleteExpressionChildAt(node: DeleteExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.deleteKeyword;
-            case 1: return node.expression;
-        }
-    }
-    function typeOfExpressionChildAt(node: TypeOfExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.typeOfKeyword;
-            case 1: return node.expression;
-        }
-    }
-    function voidExpressionChildAt(node: VoidExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.voidKeyword;
-            case 1: return node.expression;
-        }
-    }
-    function conditionalExpressionChildAt(node: ConditionalExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.condition;
-            case 1: return node.questionToken;
-            case 2: return node.whenTrue;
-            case 3: return node.colonToken;
-            case 4: return node.whenFalse;
-        }
-    }
-    function binaryExpressionChildAt(node: BinaryExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.left;
-            case 1: return node.operatorToken;
-            case 2: return node.right;
-        }
-    }
-    function postfixUnaryExpressionChildAt(node: PostfixUnaryExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.operand;
-            case 1: return node.operatorToken;
-        }
-    }
-    function memberAccessExpressionChildAt(node: MemberAccessExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.dotToken;
-            case 2: return node.name;
-        }
-    }
-    function invocationExpressionChildAt(node: InvocationExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.argumentList;
-        }
-    }
-    function arrayLiteralExpressionChildAt(node: ArrayLiteralExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBracketToken;
-            case 1: return node.expressions;
-            case 2: return node.closeBracketToken;
-        }
-    }
-    function objectLiteralExpressionChildAt(node: ObjectLiteralExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openBraceToken;
-            case 1: return node.propertyAssignments;
-            case 2: return node.closeBraceToken;
-        }
-    }
-    function objectCreationExpressionChildAt(node: ObjectCreationExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.newKeyword;
-            case 1: return node.expression;
-            case 2: return node.argumentList;
-        }
-    }
-    function parenthesizedExpressionChildAt(node: ParenthesizedExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openParenToken;
-            case 1: return node.expression;
-            case 2: return node.closeParenToken;
-        }
-    }
-    function parenthesizedArrowFunctionExpressionChildAt(node: ParenthesizedArrowFunctionExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.callSignature;
-            case 1: return node.equalsGreaterThanToken;
-            case 2: return node.block;
-            case 3: return node.expression;
-        }
-    }
-    function simpleArrowFunctionExpressionChildAt(node: SimpleArrowFunctionExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.parameter;
-            case 1: return node.equalsGreaterThanToken;
-            case 2: return node.block;
-            case 3: return node.expression;
-        }
-    }
-    function castExpressionChildAt(node: CastExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.lessThanToken;
-            case 1: return node.type;
-            case 2: return node.greaterThanToken;
-            case 3: return node.expression;
-        }
-    }
-    function elementAccessExpressionChildAt(node: ElementAccessExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.openBracketToken;
-            case 2: return node.argumentExpression;
-            case 3: return node.closeBracketToken;
-        }
-    }
-    function functionExpressionChildAt(node: FunctionExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.functionKeyword;
-            case 1: return node.identifier;
-            case 2: return node.callSignature;
-            case 3: return node.block;
-        }
-    }
-    function omittedExpressionChildAt(node: OmittedExpressionSyntax, index: number): ISyntaxElement {
-        throw Errors.invalidOperation();
-    }
-    function templateExpressionChildAt(node: TemplateExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.templateStartToken;
-            case 1: return node.templateClauses;
-        }
-    }
-    function templateAccessExpressionChildAt(node: TemplateAccessExpressionSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.templateExpression;
-        }
-    }
-    function variableDeclarationChildAt(node: VariableDeclarationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.varKeyword;
-            case 1: return node.variableDeclarators;
-        }
-    }
-    function variableDeclaratorChildAt(node: VariableDeclaratorSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.typeAnnotation;
-            case 2: return node.equalsValueClause;
-        }
-    }
-    function argumentListChildAt(node: ArgumentListSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.typeArgumentList;
-            case 1: return node.openParenToken;
-            case 2: return node.arguments;
-            case 3: return node.closeParenToken;
-        }
-    }
-    function parameterListChildAt(node: ParameterListSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.openParenToken;
-            case 1: return node.parameters;
-            case 2: return node.closeParenToken;
-        }
-    }
-    function typeArgumentListChildAt(node: TypeArgumentListSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.lessThanToken;
-            case 1: return node.typeArguments;
-            case 2: return node.greaterThanToken;
-        }
-    }
-    function typeParameterListChildAt(node: TypeParameterListSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.lessThanToken;
-            case 1: return node.typeParameters;
-            case 2: return node.greaterThanToken;
-        }
-    }
-    function heritageClauseChildAt(node: HeritageClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.extendsOrImplementsKeyword;
-            case 1: return node.typeNames;
-        }
-    }
-    function equalsValueClauseChildAt(node: EqualsValueClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.equalsToken;
-            case 1: return node.value;
-        }
-    }
-    function caseSwitchClauseChildAt(node: CaseSwitchClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.caseKeyword;
-            case 1: return node.expression;
-            case 2: return node.colonToken;
-            case 3: return node.statements;
-        }
-    }
-    function defaultSwitchClauseChildAt(node: DefaultSwitchClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.defaultKeyword;
-            case 1: return node.colonToken;
-            case 2: return node.statements;
-        }
-    }
-    function elseClauseChildAt(node: ElseClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.elseKeyword;
-            case 1: return node.statement;
-        }
-    }
-    function catchClauseChildAt(node: CatchClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.catchKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.identifier;
-            case 3: return node.typeAnnotation;
-            case 4: return node.closeParenToken;
-            case 5: return node.block;
-        }
-    }
-    function finallyClauseChildAt(node: FinallyClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.finallyKeyword;
-            case 1: return node.block;
-        }
-    }
-    function templateClauseChildAt(node: TemplateClauseSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.expression;
-            case 1: return node.templateMiddleOrEndToken;
-        }
-    }
-    function typeParameterChildAt(node: TypeParameterSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.identifier;
-            case 1: return node.constraint;
-        }
-    }
-    function constraintChildAt(node: ConstraintSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.extendsKeyword;
-            case 1: return node.typeOrExpression;
-        }
-    }
-    function simplePropertyAssignmentChildAt(node: SimplePropertyAssignmentSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.colonToken;
-            case 2: return node.expression;
-        }
-    }
-    function functionPropertyAssignmentChildAt(node: FunctionPropertyAssignmentSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.callSignature;
-            case 2: return node.block;
-        }
-    }
-    function parameterChildAt(node: ParameterSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.dotDotDotToken;
-            case 1: return node.modifiers;
-            case 2: return node.identifier;
-            case 3: return node.questionToken;
-            case 4: return node.typeAnnotation;
-            case 5: return node.equalsValueClause;
-        }
-    }
-    function enumElementChildAt(node: EnumElementSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.propertyName;
-            case 1: return node.equalsValueClause;
-        }
-    }
-    function typeAnnotationChildAt(node: TypeAnnotationSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.colonToken;
-            case 1: return node.type;
-        }
-    }
-    function externalModuleReferenceChildAt(node: ExternalModuleReferenceSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.requireKeyword;
-            case 1: return node.openParenToken;
-            case 2: return node.stringLiteral;
-            case 3: return node.closeParenToken;
-        }
-    }
-    function moduleNameModuleReferenceChildAt(node: ModuleNameModuleReferenceSyntax, index: number): ISyntaxElement {
-        switch (index) {
-            case 0: return node.moduleName;
-        }
-    }
+    var childAtArray: ((nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement)[] = [
+        undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+        (node: SourceUnitSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.moduleElements;
+                case 1: return node.endOfFileToken;
+            }
+        },
+        (node: QualifiedNameSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.left;
+                case 1: return node.dotToken;
+                case 2: return node.right;
+            }
+        },
+        (node: ObjectTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBraceToken;
+                case 1: return node.typeMembers;
+                case 2: return node.closeBraceToken;
+            }
+        },
+        (node: FunctionTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.typeParameterList;
+                case 1: return node.parameterList;
+                case 2: return node.equalsGreaterThanToken;
+                case 3: return node.type;
+            }
+        },
+        (node: ArrayTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.type;
+                case 1: return node.openBracketToken;
+                case 2: return node.closeBracketToken;
+            }
+        },
+        (node: ConstructorTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.newKeyword;
+                case 1: return node.typeParameterList;
+                case 2: return node.parameterList;
+                case 3: return node.equalsGreaterThanToken;
+                case 4: return node.type;
+            }
+        },
+        (node: GenericTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.name;
+                case 1: return node.typeArgumentList;
+            }
+        },
+        (node: TypeQuerySyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.typeOfKeyword;
+                case 1: return node.name;
+            }
+        },
+        (node: TupleTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBracketToken;
+                case 1: return node.types;
+                case 2: return node.closeBracketToken;
+            }
+        },
+        (node: UnionTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.left;
+                case 1: return node.barToken;
+                case 2: return node.right;
+            }
+        },
+        (node: ParenthesizedTypeSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openParenToken;
+                case 1: return node.type;
+                case 2: return node.closeParenToken;
+            }
+        },
+        (node: InterfaceDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.interfaceKeyword;
+                case 2: return node.identifier;
+                case 3: return node.typeParameterList;
+                case 4: return node.heritageClauses;
+                case 5: return node.body;
+            }
+        },
+        (node: FunctionDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.functionKeyword;
+                case 2: return node.identifier;
+                case 3: return node.callSignature;
+                case 4: return node.block;
+                case 5: return node.semicolonToken;
+            }
+        },
+        (node: ModuleDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.moduleKeyword;
+                case 2: return node.name;
+                case 3: return node.stringLiteral;
+                case 4: return node.openBraceToken;
+                case 5: return node.moduleElements;
+                case 6: return node.closeBraceToken;
+            }
+        },
+        (node: ClassDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.classKeyword;
+                case 2: return node.identifier;
+                case 3: return node.typeParameterList;
+                case 4: return node.heritageClauses;
+                case 5: return node.openBraceToken;
+                case 6: return node.classElements;
+                case 7: return node.closeBraceToken;
+            }
+        },
+        (node: EnumDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.enumKeyword;
+                case 2: return node.identifier;
+                case 3: return node.openBraceToken;
+                case 4: return node.enumElements;
+                case 5: return node.closeBraceToken;
+            }
+        },
+        (node: ImportDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.importKeyword;
+                case 2: return node.identifier;
+                case 3: return node.equalsToken;
+                case 4: return node.moduleReference;
+                case 5: return node.semicolonToken;
+            }
+        },
+        (node: ExportAssignmentSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.exportKeyword;
+                case 1: return node.equalsToken;
+                case 2: return node.identifier;
+                case 3: return node.semicolonToken;
+            }
+        },
+        (node: MemberFunctionDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.propertyName;
+                case 2: return node.callSignature;
+                case 3: return node.block;
+                case 4: return node.semicolonToken;
+            }
+        },
+        (node: MemberVariableDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.variableDeclarator;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: ConstructorDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.constructorKeyword;
+                case 2: return node.callSignature;
+                case 3: return node.block;
+                case 4: return node.semicolonToken;
+            }
+        },
+        (node: IndexMemberDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.indexSignature;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: GetAccessorSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.getKeyword;
+                case 2: return node.propertyName;
+                case 3: return node.callSignature;
+                case 4: return node.block;
+            }
+        },
+        (node: SetAccessorSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.setKeyword;
+                case 2: return node.propertyName;
+                case 3: return node.callSignature;
+                case 4: return node.block;
+            }
+        },
+        (node: PropertySignatureSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.questionToken;
+                case 2: return node.typeAnnotation;
+            }
+        },
+        (node: CallSignatureSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.typeParameterList;
+                case 1: return node.parameterList;
+                case 2: return node.typeAnnotation;
+            }
+        },
+        (node: ConstructSignatureSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.newKeyword;
+                case 1: return node.callSignature;
+            }
+        },
+        (node: IndexSignatureSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBracketToken;
+                case 1: return node.parameters;
+                case 2: return node.closeBracketToken;
+                case 3: return node.typeAnnotation;
+            }
+        },
+        (node: MethodSignatureSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.questionToken;
+                case 2: return node.callSignature;
+            }
+        },
+        (node: BlockSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBraceToken;
+                case 1: return node.statements;
+                case 2: return node.closeBraceToken;
+            }
+        },
+        (node: IfStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.ifKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.condition;
+                case 3: return node.closeParenToken;
+                case 4: return node.statement;
+                case 5: return node.elseClause;
+            }
+        },
+        (node: VariableStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.modifiers;
+                case 1: return node.variableDeclaration;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: ExpressionStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.semicolonToken;
+            }
+        },
+        (node: ReturnStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.returnKeyword;
+                case 1: return node.expression;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: SwitchStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.switchKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.expression;
+                case 3: return node.closeParenToken;
+                case 4: return node.openBraceToken;
+                case 5: return node.switchClauses;
+                case 6: return node.closeBraceToken;
+            }
+        },
+        (node: BreakStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.breakKeyword;
+                case 1: return node.identifier;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: ContinueStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.continueKeyword;
+                case 1: return node.identifier;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: ForStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.forKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.variableDeclaration;
+                case 3: return node.initializer;
+                case 4: return node.firstSemicolonToken;
+                case 5: return node.condition;
+                case 6: return node.secondSemicolonToken;
+                case 7: return node.incrementor;
+                case 8: return node.closeParenToken;
+                case 9: return node.statement;
+            }
+        },
+        (node: ForInStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.forKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.variableDeclaration;
+                case 3: return node.left;
+                case 4: return node.inKeyword;
+                case 5: return node.expression;
+                case 6: return node.closeParenToken;
+                case 7: return node.statement;
+            }
+        },
+        (node: EmptyStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.semicolonToken;
+            }
+        },
+        (node: ThrowStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.throwKeyword;
+                case 1: return node.expression;
+                case 2: return node.semicolonToken;
+            }
+        },
+        (node: WhileStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.whileKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.condition;
+                case 3: return node.closeParenToken;
+                case 4: return node.statement;
+            }
+        },
+        (node: TryStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.tryKeyword;
+                case 1: return node.block;
+                case 2: return node.catchClause;
+                case 3: return node.finallyClause;
+            }
+        },
+        (node: LabeledStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.identifier;
+                case 1: return node.colonToken;
+                case 2: return node.statement;
+            }
+        },
+        (node: DoStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.doKeyword;
+                case 1: return node.statement;
+                case 2: return node.whileKeyword;
+                case 3: return node.openParenToken;
+                case 4: return node.condition;
+                case 5: return node.closeParenToken;
+                case 6: return node.semicolonToken;
+            }
+        },
+        (node: DebuggerStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.debuggerKeyword;
+                case 1: return node.semicolonToken;
+            }
+        },
+        (node: WithStatementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.withKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.condition;
+                case 3: return node.closeParenToken;
+                case 4: return node.statement;
+            }
+        },
+        (node: PrefixUnaryExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.operatorToken;
+                case 1: return node.operand;
+            }
+        },
+        (node: DeleteExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.deleteKeyword;
+                case 1: return node.expression;
+            }
+        },
+        (node: TypeOfExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.typeOfKeyword;
+                case 1: return node.expression;
+            }
+        },
+        (node: VoidExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.voidKeyword;
+                case 1: return node.expression;
+            }
+        },
+        (node: ConditionalExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.condition;
+                case 1: return node.questionToken;
+                case 2: return node.whenTrue;
+                case 3: return node.colonToken;
+                case 4: return node.whenFalse;
+            }
+        },
+        (node: BinaryExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.left;
+                case 1: return node.operatorToken;
+                case 2: return node.right;
+            }
+        },
+        (node: PostfixUnaryExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.operand;
+                case 1: return node.operatorToken;
+            }
+        },
+        (node: MemberAccessExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.dotToken;
+                case 2: return node.name;
+            }
+        },
+        (node: InvocationExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.argumentList;
+            }
+        },
+        (node: ArrayLiteralExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBracketToken;
+                case 1: return node.expressions;
+                case 2: return node.closeBracketToken;
+            }
+        },
+        (node: ObjectLiteralExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openBraceToken;
+                case 1: return node.propertyAssignments;
+                case 2: return node.closeBraceToken;
+            }
+        },
+        (node: ObjectCreationExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.newKeyword;
+                case 1: return node.expression;
+                case 2: return node.argumentList;
+            }
+        },
+        (node: ParenthesizedExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openParenToken;
+                case 1: return node.expression;
+                case 2: return node.closeParenToken;
+            }
+        },
+        (node: ParenthesizedArrowFunctionExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.callSignature;
+                case 1: return node.equalsGreaterThanToken;
+                case 2: return node.block;
+                case 3: return node.expression;
+            }
+        },
+        (node: SimpleArrowFunctionExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.parameter;
+                case 1: return node.equalsGreaterThanToken;
+                case 2: return node.block;
+                case 3: return node.expression;
+            }
+        },
+        (node: CastExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.lessThanToken;
+                case 1: return node.type;
+                case 2: return node.greaterThanToken;
+                case 3: return node.expression;
+            }
+        },
+        (node: ElementAccessExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.openBracketToken;
+                case 2: return node.argumentExpression;
+                case 3: return node.closeBracketToken;
+            }
+        },
+        (node: FunctionExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.functionKeyword;
+                case 1: return node.identifier;
+                case 2: return node.callSignature;
+                case 3: return node.block;
+            }
+        },
+        (node: OmittedExpressionSyntax, index: number): ISyntaxElement => {
+            throw Errors.invalidOperation();
+        },
+        (node: TemplateExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.templateStartToken;
+                case 1: return node.templateClauses;
+            }
+        },
+        (node: TemplateAccessExpressionSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.templateExpression;
+            }
+        },
+        (node: VariableDeclarationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.varKeyword;
+                case 1: return node.variableDeclarators;
+            }
+        },
+        (node: VariableDeclaratorSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.typeAnnotation;
+                case 2: return node.equalsValueClause;
+            }
+        },
+        (node: ArgumentListSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.typeArgumentList;
+                case 1: return node.openParenToken;
+                case 2: return node.arguments;
+                case 3: return node.closeParenToken;
+            }
+        },
+        (node: ParameterListSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.openParenToken;
+                case 1: return node.parameters;
+                case 2: return node.closeParenToken;
+            }
+        },
+        (node: TypeArgumentListSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.lessThanToken;
+                case 1: return node.typeArguments;
+                case 2: return node.greaterThanToken;
+            }
+        },
+        (node: TypeParameterListSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.lessThanToken;
+                case 1: return node.typeParameters;
+                case 2: return node.greaterThanToken;
+            }
+        },
+        (node: HeritageClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.extendsOrImplementsKeyword;
+                case 1: return node.typeNames;
+            }
+        },
+        (node: EqualsValueClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.equalsToken;
+                case 1: return node.value;
+            }
+        },
+        (node: CaseSwitchClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.caseKeyword;
+                case 1: return node.expression;
+                case 2: return node.colonToken;
+                case 3: return node.statements;
+            }
+        },
+        (node: DefaultSwitchClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.defaultKeyword;
+                case 1: return node.colonToken;
+                case 2: return node.statements;
+            }
+        },
+        (node: ElseClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.elseKeyword;
+                case 1: return node.statement;
+            }
+        },
+        (node: CatchClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.catchKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.identifier;
+                case 3: return node.typeAnnotation;
+                case 4: return node.closeParenToken;
+                case 5: return node.block;
+            }
+        },
+        (node: FinallyClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.finallyKeyword;
+                case 1: return node.block;
+            }
+        },
+        (node: TemplateClauseSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.expression;
+                case 1: return node.templateMiddleOrEndToken;
+            }
+        },
+        (node: TypeParameterSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.identifier;
+                case 1: return node.constraint;
+            }
+        },
+        (node: ConstraintSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.extendsKeyword;
+                case 1: return node.typeOrExpression;
+            }
+        },
+        (node: SimplePropertyAssignmentSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.colonToken;
+                case 2: return node.expression;
+            }
+        },
+        (node: FunctionPropertyAssignmentSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.callSignature;
+                case 2: return node.block;
+            }
+        },
+        (node: ParameterSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.dotDotDotToken;
+                case 1: return node.modifiers;
+                case 2: return node.identifier;
+                case 3: return node.questionToken;
+                case 4: return node.typeAnnotation;
+                case 5: return node.equalsValueClause;
+            }
+        },
+        (node: EnumElementSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.propertyName;
+                case 1: return node.equalsValueClause;
+            }
+        },
+        (node: TypeAnnotationSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.colonToken;
+                case 1: return node.type;
+            }
+        },
+        (node: ExternalModuleReferenceSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.requireKeyword;
+                case 1: return node.openParenToken;
+                case 2: return node.stringLiteral;
+                case 3: return node.closeParenToken;
+            }
+        },
+        (node: ModuleNameModuleReferenceSyntax, index: number): ISyntaxElement => {
+            switch (index) {
+                case 0: return node.moduleName;
+            }
+        }
+    ];
     export function childAt(element: ISyntaxElement, index: number): ISyntaxElement {
         if (isList(element)) { return (<ISyntaxNodeOrToken[]>element)[index]; }
-        switch (element.kind()) {
-            case SyntaxKind.SourceUnit: return sourceUnitChildAt(<SourceUnitSyntax>element, index);
-            case SyntaxKind.QualifiedName: return qualifiedNameChildAt(<QualifiedNameSyntax>element, index);
-            case SyntaxKind.ObjectType: return objectTypeChildAt(<ObjectTypeSyntax>element, index);
-            case SyntaxKind.FunctionType: return functionTypeChildAt(<FunctionTypeSyntax>element, index);
-            case SyntaxKind.ArrayType: return arrayTypeChildAt(<ArrayTypeSyntax>element, index);
-            case SyntaxKind.ConstructorType: return constructorTypeChildAt(<ConstructorTypeSyntax>element, index);
-            case SyntaxKind.GenericType: return genericTypeChildAt(<GenericTypeSyntax>element, index);
-            case SyntaxKind.TypeQuery: return typeQueryChildAt(<TypeQuerySyntax>element, index);
-            case SyntaxKind.TupleType: return tupleTypeChildAt(<TupleTypeSyntax>element, index);
-            case SyntaxKind.UnionType: return unionTypeChildAt(<UnionTypeSyntax>element, index);
-            case SyntaxKind.ParenthesizedType: return parenthesizedTypeChildAt(<ParenthesizedTypeSyntax>element, index);
-            case SyntaxKind.InterfaceDeclaration: return interfaceDeclarationChildAt(<InterfaceDeclarationSyntax>element, index);
-            case SyntaxKind.FunctionDeclaration: return functionDeclarationChildAt(<FunctionDeclarationSyntax>element, index);
-            case SyntaxKind.ModuleDeclaration: return moduleDeclarationChildAt(<ModuleDeclarationSyntax>element, index);
-            case SyntaxKind.ClassDeclaration: return classDeclarationChildAt(<ClassDeclarationSyntax>element, index);
-            case SyntaxKind.EnumDeclaration: return enumDeclarationChildAt(<EnumDeclarationSyntax>element, index);
-            case SyntaxKind.ImportDeclaration: return importDeclarationChildAt(<ImportDeclarationSyntax>element, index);
-            case SyntaxKind.ExportAssignment: return exportAssignmentChildAt(<ExportAssignmentSyntax>element, index);
-            case SyntaxKind.MemberFunctionDeclaration: return memberFunctionDeclarationChildAt(<MemberFunctionDeclarationSyntax>element, index);
-            case SyntaxKind.MemberVariableDeclaration: return memberVariableDeclarationChildAt(<MemberVariableDeclarationSyntax>element, index);
-            case SyntaxKind.ConstructorDeclaration: return constructorDeclarationChildAt(<ConstructorDeclarationSyntax>element, index);
-            case SyntaxKind.IndexMemberDeclaration: return indexMemberDeclarationChildAt(<IndexMemberDeclarationSyntax>element, index);
-            case SyntaxKind.GetAccessor: return getAccessorChildAt(<GetAccessorSyntax>element, index);
-            case SyntaxKind.SetAccessor: return setAccessorChildAt(<SetAccessorSyntax>element, index);
-            case SyntaxKind.PropertySignature: return propertySignatureChildAt(<PropertySignatureSyntax>element, index);
-            case SyntaxKind.CallSignature: return callSignatureChildAt(<CallSignatureSyntax>element, index);
-            case SyntaxKind.ConstructSignature: return constructSignatureChildAt(<ConstructSignatureSyntax>element, index);
-            case SyntaxKind.IndexSignature: return indexSignatureChildAt(<IndexSignatureSyntax>element, index);
-            case SyntaxKind.MethodSignature: return methodSignatureChildAt(<MethodSignatureSyntax>element, index);
-            case SyntaxKind.Block: return blockChildAt(<BlockSyntax>element, index);
-            case SyntaxKind.IfStatement: return ifStatementChildAt(<IfStatementSyntax>element, index);
-            case SyntaxKind.VariableStatement: return variableStatementChildAt(<VariableStatementSyntax>element, index);
-            case SyntaxKind.ExpressionStatement: return expressionStatementChildAt(<ExpressionStatementSyntax>element, index);
-            case SyntaxKind.ReturnStatement: return returnStatementChildAt(<ReturnStatementSyntax>element, index);
-            case SyntaxKind.SwitchStatement: return switchStatementChildAt(<SwitchStatementSyntax>element, index);
-            case SyntaxKind.BreakStatement: return breakStatementChildAt(<BreakStatementSyntax>element, index);
-            case SyntaxKind.ContinueStatement: return continueStatementChildAt(<ContinueStatementSyntax>element, index);
-            case SyntaxKind.ForStatement: return forStatementChildAt(<ForStatementSyntax>element, index);
-            case SyntaxKind.ForInStatement: return forInStatementChildAt(<ForInStatementSyntax>element, index);
-            case SyntaxKind.EmptyStatement: return emptyStatementChildAt(<EmptyStatementSyntax>element, index);
-            case SyntaxKind.ThrowStatement: return throwStatementChildAt(<ThrowStatementSyntax>element, index);
-            case SyntaxKind.WhileStatement: return whileStatementChildAt(<WhileStatementSyntax>element, index);
-            case SyntaxKind.TryStatement: return tryStatementChildAt(<TryStatementSyntax>element, index);
-            case SyntaxKind.LabeledStatement: return labeledStatementChildAt(<LabeledStatementSyntax>element, index);
-            case SyntaxKind.DoStatement: return doStatementChildAt(<DoStatementSyntax>element, index);
-            case SyntaxKind.DebuggerStatement: return debuggerStatementChildAt(<DebuggerStatementSyntax>element, index);
-            case SyntaxKind.WithStatement: return withStatementChildAt(<WithStatementSyntax>element, index);
-            case SyntaxKind.PrefixUnaryExpression: return prefixUnaryExpressionChildAt(<PrefixUnaryExpressionSyntax>element, index);
-            case SyntaxKind.DeleteExpression: return deleteExpressionChildAt(<DeleteExpressionSyntax>element, index);
-            case SyntaxKind.TypeOfExpression: return typeOfExpressionChildAt(<TypeOfExpressionSyntax>element, index);
-            case SyntaxKind.VoidExpression: return voidExpressionChildAt(<VoidExpressionSyntax>element, index);
-            case SyntaxKind.ConditionalExpression: return conditionalExpressionChildAt(<ConditionalExpressionSyntax>element, index);
-            case SyntaxKind.BinaryExpression: return binaryExpressionChildAt(<BinaryExpressionSyntax>element, index);
-            case SyntaxKind.PostfixUnaryExpression: return postfixUnaryExpressionChildAt(<PostfixUnaryExpressionSyntax>element, index);
-            case SyntaxKind.MemberAccessExpression: return memberAccessExpressionChildAt(<MemberAccessExpressionSyntax>element, index);
-            case SyntaxKind.InvocationExpression: return invocationExpressionChildAt(<InvocationExpressionSyntax>element, index);
-            case SyntaxKind.ArrayLiteralExpression: return arrayLiteralExpressionChildAt(<ArrayLiteralExpressionSyntax>element, index);
-            case SyntaxKind.ObjectLiteralExpression: return objectLiteralExpressionChildAt(<ObjectLiteralExpressionSyntax>element, index);
-            case SyntaxKind.ObjectCreationExpression: return objectCreationExpressionChildAt(<ObjectCreationExpressionSyntax>element, index);
-            case SyntaxKind.ParenthesizedExpression: return parenthesizedExpressionChildAt(<ParenthesizedExpressionSyntax>element, index);
-            case SyntaxKind.ParenthesizedArrowFunctionExpression: return parenthesizedArrowFunctionExpressionChildAt(<ParenthesizedArrowFunctionExpressionSyntax>element, index);
-            case SyntaxKind.SimpleArrowFunctionExpression: return simpleArrowFunctionExpressionChildAt(<SimpleArrowFunctionExpressionSyntax>element, index);
-            case SyntaxKind.CastExpression: return castExpressionChildAt(<CastExpressionSyntax>element, index);
-            case SyntaxKind.ElementAccessExpression: return elementAccessExpressionChildAt(<ElementAccessExpressionSyntax>element, index);
-            case SyntaxKind.FunctionExpression: return functionExpressionChildAt(<FunctionExpressionSyntax>element, index);
-            case SyntaxKind.OmittedExpression: return omittedExpressionChildAt(<OmittedExpressionSyntax>element, index);
-            case SyntaxKind.TemplateExpression: return templateExpressionChildAt(<TemplateExpressionSyntax>element, index);
-            case SyntaxKind.TemplateAccessExpression: return templateAccessExpressionChildAt(<TemplateAccessExpressionSyntax>element, index);
-            case SyntaxKind.VariableDeclaration: return variableDeclarationChildAt(<VariableDeclarationSyntax>element, index);
-            case SyntaxKind.VariableDeclarator: return variableDeclaratorChildAt(<VariableDeclaratorSyntax>element, index);
-            case SyntaxKind.ArgumentList: return argumentListChildAt(<ArgumentListSyntax>element, index);
-            case SyntaxKind.ParameterList: return parameterListChildAt(<ParameterListSyntax>element, index);
-            case SyntaxKind.TypeArgumentList: return typeArgumentListChildAt(<TypeArgumentListSyntax>element, index);
-            case SyntaxKind.TypeParameterList: return typeParameterListChildAt(<TypeParameterListSyntax>element, index);
-            case SyntaxKind.HeritageClause: return heritageClauseChildAt(<HeritageClauseSyntax>element, index);
-            case SyntaxKind.EqualsValueClause: return equalsValueClauseChildAt(<EqualsValueClauseSyntax>element, index);
-            case SyntaxKind.CaseSwitchClause: return caseSwitchClauseChildAt(<CaseSwitchClauseSyntax>element, index);
-            case SyntaxKind.DefaultSwitchClause: return defaultSwitchClauseChildAt(<DefaultSwitchClauseSyntax>element, index);
-            case SyntaxKind.ElseClause: return elseClauseChildAt(<ElseClauseSyntax>element, index);
-            case SyntaxKind.CatchClause: return catchClauseChildAt(<CatchClauseSyntax>element, index);
-            case SyntaxKind.FinallyClause: return finallyClauseChildAt(<FinallyClauseSyntax>element, index);
-            case SyntaxKind.TemplateClause: return templateClauseChildAt(<TemplateClauseSyntax>element, index);
-            case SyntaxKind.TypeParameter: return typeParameterChildAt(<TypeParameterSyntax>element, index);
-            case SyntaxKind.Constraint: return constraintChildAt(<ConstraintSyntax>element, index);
-            case SyntaxKind.SimplePropertyAssignment: return simplePropertyAssignmentChildAt(<SimplePropertyAssignmentSyntax>element, index);
-            case SyntaxKind.FunctionPropertyAssignment: return functionPropertyAssignmentChildAt(<FunctionPropertyAssignmentSyntax>element, index);
-            case SyntaxKind.Parameter: return parameterChildAt(<ParameterSyntax>element, index);
-            case SyntaxKind.EnumElement: return enumElementChildAt(<EnumElementSyntax>element, index);
-            case SyntaxKind.TypeAnnotation: return typeAnnotationChildAt(<TypeAnnotationSyntax>element, index);
-            case SyntaxKind.ExternalModuleReference: return externalModuleReferenceChildAt(<ExternalModuleReferenceSyntax>element, index);
-            case SyntaxKind.ModuleNameModuleReference: return moduleNameModuleReferenceChildAt(<ModuleNameModuleReferenceSyntax>element, index);
-        }
+        return childAtArray[element.kind](element, index);
+    }
+
+    export function getChildAtFunction(element: ISyntaxNodeOrToken): (nodeOrToken: ISyntaxElement, index: number) => ISyntaxElement {
+        return childAtArray[element.kind];
     }
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxUtilities.ts b/src/services/syntax/syntaxUtilities.ts
index 06525cf81b6..65748b5e902 100644
--- a/src/services/syntax/syntaxUtilities.ts
+++ b/src/services/syntax/syntaxUtilities.ts
@@ -3,7 +3,7 @@
 module TypeScript {
     export class SyntaxUtilities {
         public static isAnyFunctionExpressionOrDeclaration(ast: ISyntaxElement): boolean {
-            switch (ast.kind()) {
+            switch (ast.kind) {
                 case SyntaxKind.SimpleArrowFunctionExpression:
                 case SyntaxKind.ParenthesizedArrowFunctionExpression:
                 case SyntaxKind.FunctionExpression:
@@ -34,7 +34,7 @@ module TypeScript {
 
         public static isLeftHandSizeExpression(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.MemberAccessExpression:
                     case SyntaxKind.ElementAccessExpression:
                     case SyntaxKind.TemplateAccessExpression:
@@ -62,7 +62,7 @@ module TypeScript {
 
         public static isSwitchClause(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.CaseSwitchClause:
                     case SyntaxKind.DefaultSwitchClause:
                         return true;
@@ -74,7 +74,7 @@ module TypeScript {
 
         public static isTypeMember(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.ConstructSignature:
                     case SyntaxKind.MethodSignature:
                     case SyntaxKind.IndexSignature:
@@ -89,7 +89,7 @@ module TypeScript {
 
         public static isClassElement(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.ConstructorDeclaration:
                     case SyntaxKind.IndexMemberDeclaration:
                     case SyntaxKind.MemberFunctionDeclaration:
@@ -106,7 +106,7 @@ module TypeScript {
 
         public static isModuleElement(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.ImportDeclaration:
                     case SyntaxKind.ExportAssignment:
                     case SyntaxKind.ClassDeclaration:
@@ -143,7 +143,7 @@ module TypeScript {
 
         public static isStatement(element: ISyntaxElement) {
             if (element) {
-                switch (element.kind()) {
+                switch (element.kind) {
                     case SyntaxKind.FunctionDeclaration:
                     case SyntaxKind.VariableStatement:
                     case SyntaxKind.Block:
@@ -173,8 +173,8 @@ module TypeScript {
         public static isAngleBracket(positionedElement: ISyntaxElement): boolean {
             var element = positionedElement;
             var parent = positionedElement.parent;
-            if (parent && (element.kind() === SyntaxKind.LessThanToken || element.kind() === SyntaxKind.GreaterThanToken)) {
-                switch (parent.kind()) {
+            if (parent && (element.kind === SyntaxKind.LessThanToken || element.kind === SyntaxKind.GreaterThanToken)) {
+                switch (parent.kind) {
                     case SyntaxKind.TypeArgumentList:
                     case SyntaxKind.TypeParameterList:
                     case SyntaxKind.CastExpression:
@@ -188,7 +188,7 @@ module TypeScript {
         public static getToken(list: ISyntaxToken[], kind: SyntaxKind): ISyntaxToken {
             for (var i = 0, n = list.length; i < n; i++) {
                 var token = list[i];
-                if (token.kind() === kind) {
+                if (token.kind === kind) {
                     return token;
                 }
             }
@@ -205,7 +205,7 @@ module TypeScript {
         }
 
         public static getExportKeyword(moduleElement: IModuleElementSyntax): ISyntaxToken {
-            switch (moduleElement.kind()) {
+            switch (moduleElement.kind) {
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.FunctionDeclaration:
@@ -225,7 +225,7 @@ module TypeScript {
             }
 
             var node = positionNode;
-            switch (node.kind()) {
+            switch (node.kind) {
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.FunctionDeclaration:
diff --git a/src/services/syntax/syntaxVisitor.generated.ts b/src/services/syntax/syntaxVisitor.generated.ts
index 4eca73a7765..c3fe7c48558 100644
--- a/src/services/syntax/syntaxVisitor.generated.ts
+++ b/src/services/syntax/syntaxVisitor.generated.ts
@@ -3,7 +3,7 @@
 module TypeScript {
     export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {
         if (element === undefined) { return undefined; }
-        switch (element.kind()) {
+        switch (element.kind) {
             case SyntaxKind.SourceUnit: return visitor.visitSourceUnit(<SourceUnitSyntax>element);
             case SyntaxKind.QualifiedName: return visitor.visitQualifiedName(<QualifiedNameSyntax>element);
             case SyntaxKind.ObjectType: return visitor.visitObjectType(<ObjectTypeSyntax>element);
diff --git a/src/services/syntax/testUtilities.ts b/src/services/syntax/testUtilities.ts
index 1febd184a8c..8a77c3f8314 100644
--- a/src/services/syntax/testUtilities.ts
+++ b/src/services/syntax/testUtilities.ts
@@ -9,10 +9,10 @@ module TypeScript {
         if (node1 === node2) { return true; }
         if (!node1 || !node2) { return false; }
 
-        Debug.assert(node1.kind() === TypeScript.SyntaxKind.SourceUnit || node1.parent);
-        Debug.assert(node2.kind() === TypeScript.SyntaxKind.SourceUnit || node2.parent);
+        Debug.assert(node1.kind === TypeScript.SyntaxKind.SourceUnit || node1.parent);
+        Debug.assert(node2.kind === TypeScript.SyntaxKind.SourceUnit || node2.parent);
 
-        if (node1.kind() !== node2.kind()) { return false; }
+        if (node1.kind !== node2.kind) { return false; }
         if (childCount(node1) !== childCount(node2)) { return false; }
 
         for (var i = 0, n = childCount(node1); i < n; i++) {
@@ -41,8 +41,8 @@ module TypeScript {
             return false;
         }
 
-        Debug.assert(node1.kind() === TypeScript.SyntaxKind.SourceUnit || node1.parent);
-        Debug.assert(node2.kind() === TypeScript.SyntaxKind.SourceUnit || node2.parent);
+        Debug.assert(node1.kind === TypeScript.SyntaxKind.SourceUnit || node1.parent);
+        Debug.assert(node2.kind === TypeScript.SyntaxKind.SourceUnit || node2.parent);
 
         if (TypeScript.isToken(node1)) {
             return TypeScript.isToken(node2) ? tokenStructuralEquals(<TypeScript.ISyntaxToken>node1, <TypeScript.ISyntaxToken>node2, text1, text2) : false;
@@ -63,7 +63,7 @@ module TypeScript {
         Debug.assert(token1.parent);
         Debug.assert(token2.parent);
 
-        return token1.kind() === token2.kind() &&
+        return token1.kind === token2.kind &&
             TypeScript.width(token1) === TypeScript.width(token2) &&
             token1.fullWidth() === token2.fullWidth() &&
             token1.fullStart() === token2.fullStart() &&
@@ -135,10 +135,10 @@ module TypeScript {
             return false;
         }
 
-        Debug.assert(element1.kind() === SyntaxKind.SourceUnit || element1.parent);
-        Debug.assert(element2.kind() === SyntaxKind.SourceUnit || element2.parent);
+        Debug.assert(element1.kind === SyntaxKind.SourceUnit || element1.parent);
+        Debug.assert(element2.kind === SyntaxKind.SourceUnit || element2.parent);
 
-        if (element2.kind() !== element2.kind()) {
+        if (element2.kind !== element2.kind) {
             return false;
         }
 
diff --git a/src/services/syntax/utilities.generated.ts b/src/services/syntax/utilities.generated.ts
new file mode 100644
index 00000000000..a01618fae48
--- /dev/null
+++ b/src/services/syntax/utilities.generated.ts
@@ -0,0 +1,4 @@
+        var fixedWidthArray = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 8, 8, 7, 6, 2, 4, 5, 7, 3, 8, 2, 2, 10, 3, 4, 6, 6, 4, 5, 4, 3, 6, 3, 4, 5, 4, 5, 5, 4, 6, 7, 6, 5, 10, 9, 3, 7, 7, 9, 6, 6, 5, 3, 7, 11, 7, 3, 6, 7, 6, 3, 6, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, 3, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 2, 2, 2, 1, 2];
+        function fixedWidthTokenLength(kind: SyntaxKind) {
+            return fixedWidthArray[kind];
+        }