Merge pull request #1050 from Microsoft/incrementalPerf2

More incremental perf tweaks.

Author: CyrusNajmabadi

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,

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

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;
                 }
 

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 {

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

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) {

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);

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;
                 }
             }