From 0962a8869b931b56beb5e8a8ee97f43be6ef8e2b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Sat, 1 Nov 2014 16:48:54 -0700
Subject: [PATCH] Remove abstract syntax tree generation support from fidelity.

---
 src/services/syntax/SyntaxGenerator.js        |  23 +-
 src/services/syntax/incrementalParser.ts      |   1 -
 src/services/syntax/parser.ts                 | 235 ++++-----
 src/services/syntax/references.ts             |   1 -
 src/services/syntax/syntaxGenerator.ts        |  72 +--
 .../syntax/syntaxInterfaces.generated.ts      | 499 ------------------
 .../syntax/syntaxNodes.concrete.generated.ts  |   6 +-
 .../syntaxNodes.interfaces.generated.ts       |  94 ----
 src/services/syntax/syntaxTree.ts             |   9 +-
 9 files changed, 118 insertions(+), 822 deletions(-)
 delete mode 100644 src/services/syntax/syntaxInterfaces.generated.ts

diff --git a/src/services/syntax/SyntaxGenerator.js b/src/services/syntax/SyntaxGenerator.js
index 5c912b9f8f5a3..adb64b3942c4c 100644
--- a/src/services/syntax/SyntaxGenerator.js
+++ b/src/services/syntax/SyntaxGenerator.js
@@ -2596,21 +2596,7 @@ function generateSyntaxInterfaces() {
         }
         result += generateSyntaxInterface(definition);
     }
-    result += "\r\n\r\n";
-    result += "    export module Syntax {\r\n";
-    result += "        export interface ISyntaxFactory {\r\n";
-    result += "            isConcrete: boolean;\r\n";
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        result += "            " + definition.name + ": { new(data: number";
-        for (var j = 0; j < definition.children.length; j++) {
-            var child = definition.children[j];
-            result += ", " + child.name + ": " + getType(child);
-        }
-        result += "): " + definition.name + " };\r\n";
-    }
-    result += "        }\r\n";
-    result += "    }\r\n";
+    result += "\r\n";
     result += "}";
     return result;
 }
@@ -2633,13 +2619,8 @@ function generateSyntaxInterface(definition) {
 }
 function generateNodes(abstract) {
     var result = "///<reference path='references.ts' />\r\n\r\n";
-    result += "module TypeScript.Syntax.";
-    var moduleName = abstract ? "Abstract" : "Concrete";
-    result += moduleName;
+    result += "module TypeScript";
     result += " {\r\n";
-    result += "    // Inject this module as the factory for producing syntax nodes in the parser.\r\n";
-    result += "    Parser.syntaxFactory = " + moduleName + ";\r\n";
-    result += "    export var isConcrete: boolean = " + !abstract + ";\r\n\r\n";
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
         if (i > 0) {
diff --git a/src/services/syntax/incrementalParser.ts b/src/services/syntax/incrementalParser.ts
index 834a5696c62e8..c30672e5042b8 100644
--- a/src/services/syntax/incrementalParser.ts
+++ b/src/services/syntax/incrementalParser.ts
@@ -855,7 +855,6 @@ module TypeScript.IncrementalParser {
     var setTokenFullStartWalker = new SetTokenFullStartWalker();
 
     export function parse(oldSyntaxTree: SyntaxTree, textChangeRange: TextChangeRange, newText: ISimpleText): SyntaxTree {
-        Debug.assert(oldSyntaxTree.isConcrete(), "Can only incrementally parse a concrete syntax tree.");
         if (textChangeRange.isUnchanged()) {
             return oldSyntaxTree;
         }
diff --git a/src/services/syntax/parser.ts b/src/services/syntax/parser.ts
index bae8ce1ad8928..8572adce30543 100644
--- a/src/services/syntax/parser.ts
+++ b/src/services/syntax/parser.ts
@@ -1,10 +1,6 @@
 ///<reference path='references.ts' />
 
 module TypeScript.Parser {
-    // The factory used to produce parse tree nodes.  Injected normally by the 
-    // TypeScript.Syntax.Abstract or TypeScript.Syntax.Conrete modules.
-    export var syntaxFactory: Syntax.ISyntaxFactory;
-
     // Interface that represents the source that the parser pulls tokens from.  Essentially, this 
     // is the interface that the parser needs an underlying scanner to provide.  This allows us to
     // separate out "what" the parser does with the tokens it retrieves versus "how" it obtains
@@ -226,7 +222,7 @@ module TypeScript.Parser {
             var allDiagnostics = source.tokenDiagnostics().concat(diagnostics);
             allDiagnostics.sort((a: Diagnostic, b: Diagnostic) => a.start() - b.start());
 
-            return new SyntaxTree(syntaxFactory.isConcrete, sourceUnit, isDeclaration, allDiagnostics, fileName, source.text, languageVersion);
+            return new SyntaxTree(sourceUnit, isDeclaration, allDiagnostics, fileName, source.text, languageVersion);
         }
 
         function getRewindPoint(): IParserRewindPoint {
@@ -704,7 +700,7 @@ module TypeScript.Parser {
 
             setStrictMode(savedIsInStrictMode);
 
-            var sourceUnit = new syntaxFactory.SourceUnitSyntax(parseNodeData, moduleElements, currentToken());
+            var sourceUnit = new SourceUnitSyntax(parseNodeData, moduleElements, currentToken());
 
             sourceUnit = <SourceUnitSyntax>addSkippedTokensBeforeNode(sourceUnit, skippedTokens);
 
@@ -817,12 +813,12 @@ module TypeScript.Parser {
         }
 
         function parseImportDeclaration(): ImportDeclarationSyntax {
-            return new syntaxFactory.ImportDeclarationSyntax(parseNodeData,
+            return new ImportDeclarationSyntax(parseNodeData,
                 parseModifiers(), eatToken(SyntaxKind.ImportKeyword), eatIdentifierToken(), eatToken(SyntaxKind.EqualsToken), parseModuleReference(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
         function parseExportAssignment(): ExportAssignmentSyntax {
-            return new syntaxFactory.ExportAssignmentSyntax(parseNodeData,
+            return new ExportAssignmentSyntax(parseNodeData,
                 eatToken(SyntaxKind.ExportKeyword), eatToken(SyntaxKind.EqualsToken), eatIdentifierToken(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
@@ -836,12 +832,12 @@ module TypeScript.Parser {
         }
 
         function parseExternalModuleReference(): ExternalModuleReferenceSyntax {
-            return new syntaxFactory.ExternalModuleReferenceSyntax(parseNodeData,
+            return new ExternalModuleReferenceSyntax(parseNodeData,
                 eatToken(SyntaxKind.RequireKeyword), eatToken(SyntaxKind.OpenParenToken), eatToken(SyntaxKind.StringLiteral), eatToken(SyntaxKind.CloseParenToken));
         }
 
         function parseModuleNameModuleReference(): ModuleNameModuleReferenceSyntax {
-            return new syntaxFactory.ModuleNameModuleReferenceSyntax(parseNodeData, parseName(/*allowIdentifierNames:*/ false));
+            return new ModuleNameModuleReferenceSyntax(parseNodeData, parseName(/*allowIdentifierNames:*/ false));
         }
 
         function tryParseTypeArgumentList(inExpression: boolean): TypeArgumentListSyntax {
@@ -859,7 +855,7 @@ module TypeScript.Parser {
                 var typeArguments = parseSeparatedSyntaxList<ITypeSyntax>(ListParsingState.TypeArgumentList_Types, skippedTokens);
                 lessThanToken = addSkippedTokensAfterToken(lessThanToken, skippedTokens);
 
-                return new syntaxFactory.TypeArgumentListSyntax(parseNodeData, lessThanToken, typeArguments, eatToken(SyntaxKind.GreaterThanToken));
+                return new TypeArgumentListSyntax(parseNodeData, lessThanToken, typeArguments, eatToken(SyntaxKind.GreaterThanToken));
             }
 
             // If we're in an expression, then we only want to consume this as a type argument list
@@ -886,7 +882,7 @@ module TypeScript.Parser {
             }
             else {
                 releaseRewindPoint(rewindPoint);
-                return new syntaxFactory.TypeArgumentListSyntax(parseNodeData, lessThanToken, typeArguments, greaterThanToken);
+                return new TypeArgumentListSyntax(parseNodeData, lessThanToken, typeArguments, greaterThanToken);
             }
         }
 
@@ -979,7 +975,7 @@ module TypeScript.Parser {
                 var dotToken = consumeToken(currentToken());
                 var identifierName = eatRightSideOfName(allowIdentifierNames);
 
-                current = new syntaxFactory.QualifiedNameSyntax(parseNodeData, current, dotToken, identifierName);
+                current = new QualifiedNameSyntax(parseNodeData, current, dotToken, identifierName);
                 shouldContinue = identifierName.fullWidth() > 0;
             }
 
@@ -1000,7 +996,7 @@ module TypeScript.Parser {
                 openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
             }
 
-            return new syntaxFactory.EnumDeclarationSyntax(parseNodeData, modifiers, enumKeyword, identifier, openBraceToken, enumElements, eatToken(SyntaxKind.CloseBraceToken));
+            return new EnumDeclarationSyntax(parseNodeData, modifiers, enumKeyword, identifier, openBraceToken, enumElements, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function isEnumElement(inErrorRecovery: boolean): boolean {
@@ -1027,7 +1023,7 @@ module TypeScript.Parser {
                 return undefined;
             }
 
-            return new syntaxFactory.EnumElementSyntax(parseNodeData, eatPropertyName(), tryParseEnumElementEqualsValueClause());
+            return new EnumElementSyntax(parseNodeData, eatPropertyName(), tryParseEnumElementEqualsValueClause());
         }
 
         function isModifierKind(kind: SyntaxKind): boolean {
@@ -1130,7 +1126,7 @@ module TypeScript.Parser {
                 openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
             };
 
-            return new syntaxFactory.ClassDeclarationSyntax(parseNodeData,
+            return new ClassDeclarationSyntax(parseNodeData,
                 modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, eatToken(SyntaxKind.CloseBraceToken));
         }
 
@@ -1161,14 +1157,14 @@ module TypeScript.Parser {
         }
 
         function parseGetMemberAccessorDeclaration(modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, checkForStrictMode: boolean): GetAccessorSyntax {
-            return new syntaxFactory.GetAccessorSyntax(parseNodeData,
+            return new GetAccessorSyntax(parseNodeData,
                 modifiers, consumeToken(getKeyword), eatPropertyName(),
                 parseCallSignature(/*requireCompleteTypeParameterList:*/ false),
                 parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, checkForStrictMode));
         }
 
         function parseSetMemberAccessorDeclaration(modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, checkForStrictMode: boolean): SetAccessorSyntax {
-            return new syntaxFactory.SetAccessorSyntax(parseNodeData,
+            return new SetAccessorSyntax(parseNodeData,
                 modifiers, consumeToken(setKeyword), eatPropertyName(),
                 parseCallSignature(/*requireCompleteTypeParameterList:*/ false),
                 parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, checkForStrictMode));
@@ -1240,7 +1236,7 @@ module TypeScript.Parser {
                 semicolonToken = eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false);
             }
 
-            return new syntaxFactory.ConstructorDeclarationSyntax(parseNodeData, modifiers, constructorKeyword, callSignature, block, semicolonToken);
+            return new ConstructorDeclarationSyntax(parseNodeData, modifiers, constructorKeyword, callSignature, block, semicolonToken);
         }
 
         function isMemberFunctionDeclaration(modifierCount: number, inErrorRecovery: boolean): boolean {
@@ -1266,7 +1262,7 @@ module TypeScript.Parser {
                 semicolon = eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false);
             }
 
-            return new syntaxFactory.MemberFunctionDeclarationSyntax(parseNodeData, modifiers, propertyName, callSignature, block, semicolon);
+            return new MemberFunctionDeclarationSyntax(parseNodeData, modifiers, propertyName, callSignature, block, semicolon);
         }
         
         function isDefinitelyMemberVariablePropertyName(index: number): boolean {
@@ -1302,7 +1298,7 @@ module TypeScript.Parser {
         }
 
         function parseMemberVariableDeclaration(): MemberVariableDeclarationSyntax {
-            return new syntaxFactory.MemberVariableDeclarationSyntax(parseNodeData,
+            return new MemberVariableDeclarationSyntax(parseNodeData,
                 parseModifiers(),
                 tryParseVariableDeclarator(/*allowIn:*/ true, /*allowPropertyName:*/ true), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
@@ -1312,7 +1308,7 @@ module TypeScript.Parser {
         }
 
         function parseIndexMemberDeclaration(): IndexMemberDeclarationSyntax {
-            return new syntaxFactory.IndexMemberDeclarationSyntax(parseNodeData,
+            return new IndexMemberDeclarationSyntax(parseNodeData,
                 parseModifiers(), parseIndexSignature(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewLine:*/ false));
         }
 
@@ -1335,11 +1331,7 @@ module TypeScript.Parser {
 
                     consumeToken(token0);
 
-                    // Note: we only do this if we're creating a concrete syntax tree (which contains
-                    // everything, including skipped tokens, in it).
-                    if (syntaxFactory.isConcrete) {
-                        addSkippedTokenAfterNode(callSignature, token0);
-                    }
+                    addSkippedTokenAfterNode(callSignature, token0);
                     return true;
                 }
             }
@@ -1373,7 +1365,7 @@ module TypeScript.Parser {
                 semicolonToken = eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false);
             }
 
-            return new syntaxFactory.FunctionDeclarationSyntax(parseNodeData, modifiers, functionKeyword, identifier, callSignature, block, semicolonToken);
+            return new FunctionDeclarationSyntax(parseNodeData, modifiers, functionKeyword, identifier, callSignature, block, semicolonToken);
         }
 
         function parseModuleDeclaration(): ModuleDeclarationSyntax {
@@ -1399,12 +1391,12 @@ module TypeScript.Parser {
                 openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
             }
 
-            return new syntaxFactory.ModuleDeclarationSyntax(parseNodeData,
+            return new ModuleDeclarationSyntax(parseNodeData,
                 modifiers, moduleKeyword, moduleName, stringLiteral, openBraceToken, moduleElements, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function parseInterfaceDeclaration(): InterfaceDeclarationSyntax {
-            return new syntaxFactory.InterfaceDeclarationSyntax(parseNodeData,
+            return new InterfaceDeclarationSyntax(parseNodeData,
                 parseModifiers(), eatToken(SyntaxKind.InterfaceKeyword), eatIdentifierToken(),
                 tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false), parseHeritageClauses(), parseObjectType());
         }
@@ -1419,7 +1411,7 @@ module TypeScript.Parser {
                 openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
             }
 
-            return new syntaxFactory.ObjectTypeSyntax(parseNodeData, openBraceToken, typeMembers, eatToken(SyntaxKind.CloseBraceToken));
+            return new ObjectTypeSyntax(parseNodeData, openBraceToken, typeMembers, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function parseTupleType(currentToken: ISyntaxToken): TupleTypeSyntax {
@@ -1432,7 +1424,7 @@ module TypeScript.Parser {
                 openBracket = addSkippedTokensAfterToken(openBracket, skippedTokens);
             }
 
-            return new syntaxFactory.TupleTypeSyntax(parseNodeData, openBracket, types, eatToken(SyntaxKind.CloseBracketToken));
+            return new TupleTypeSyntax(parseNodeData, openBracket, types, eatToken(SyntaxKind.CloseBracketToken));
         }
 
         function isTypeMember(inErrorRecovery: boolean): boolean {
@@ -1477,7 +1469,7 @@ module TypeScript.Parser {
         }
 
         function parseConstructSignature(): ConstructSignatureSyntax {
-            return new syntaxFactory.ConstructSignatureSyntax(parseNodeData, eatToken(SyntaxKind.NewKeyword), parseCallSignature(/*requireCompleteTypeParameterList:*/ false));
+            return new ConstructSignatureSyntax(parseNodeData, eatToken(SyntaxKind.NewKeyword), parseCallSignature(/*requireCompleteTypeParameterList:*/ false));
         }
 
         function parseIndexSignature(): IndexSignatureSyntax {
@@ -1487,17 +1479,17 @@ module TypeScript.Parser {
             var parameters = parseSeparatedSyntaxList<ParameterSyntax>(ListParsingState.IndexSignature_Parameters, skippedTokens);
             openBracketToken = addSkippedTokensAfterToken(openBracketToken, skippedTokens);
 
-            return new syntaxFactory.IndexSignatureSyntax(parseNodeData,
+            return new IndexSignatureSyntax(parseNodeData,
                 openBracketToken, parameters, eatToken(SyntaxKind.CloseBracketToken), parseOptionalTypeAnnotation(/*allowStringLiteral:*/ false));
         }
 
         function parseMethodSignature(): MethodSignatureSyntax {
-            return new syntaxFactory.MethodSignatureSyntax(parseNodeData,
+            return new MethodSignatureSyntax(parseNodeData,
                 eatPropertyName(), tryEatToken(SyntaxKind.QuestionToken), parseCallSignature(/*requireCompleteTypeParameterList:*/ false));
         }
 
         function parsePropertySignature(): PropertySignatureSyntax {
-            return new syntaxFactory.PropertySignatureSyntax(parseNodeData,
+            return new PropertySignatureSyntax(parseNodeData,
                 eatPropertyName(), tryEatToken(SyntaxKind.QuestionToken), parseOptionalTypeAnnotation(/*allowStringLiteral:*/ false));
         }
 
@@ -1602,7 +1594,7 @@ module TypeScript.Parser {
             var typeNames = parseSeparatedSyntaxList<INameSyntax>(ListParsingState.HeritageClause_TypeNameList, skippedTokens);
             extendsOrImplementsKeyword = addSkippedTokensAfterToken(extendsOrImplementsKeyword, skippedTokens);
 
-            return new syntaxFactory.HeritageClauseSyntax(parseNodeData, extendsOrImplementsKeyword, typeNames);
+            return new HeritageClauseSyntax(parseNodeData, extendsOrImplementsKeyword, typeNames);
         }
 
         function isInterfaceEnumClassModuleImportOrExport(modifierCount: number): boolean {
@@ -1790,7 +1782,7 @@ module TypeScript.Parser {
         }
 
         function parseDebuggerStatement(debuggerKeyword: ISyntaxToken): DebuggerStatementSyntax {
-            return new syntaxFactory.DebuggerStatementSyntax(parseNodeData, consumeToken(debuggerKeyword), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
+            return new DebuggerStatementSyntax(parseNodeData, consumeToken(debuggerKeyword), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
         function parseDoStatement(doKeyword: ISyntaxToken): DoStatementSyntax {
@@ -1798,7 +1790,7 @@ module TypeScript.Parser {
             // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in 
             // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
             //  do;while(0)x will have a semicolon inserted before x.
-            return new syntaxFactory.DoStatementSyntax(parseNodeData,
+            return new DoStatementSyntax(parseNodeData,
                 consumeToken(doKeyword), parseStatement(/*inErrorRecovery:*/ false), eatToken(SyntaxKind.WhileKeyword), eatToken(SyntaxKind.OpenParenToken),
                 parseExpression(/*allowIn:*/ true), eatToken(SyntaxKind.CloseParenToken), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ true));
         }
@@ -1808,7 +1800,7 @@ module TypeScript.Parser {
         }
 
         function parseLabeledStatement(identifierToken: ISyntaxToken): LabeledStatementSyntax {
-            return new syntaxFactory.LabeledStatementSyntax(parseNodeData,
+            return new LabeledStatementSyntax(parseNodeData,
                 consumeToken(identifierToken), eatToken(SyntaxKind.ColonToken), parseStatement(/*inErrorRecovery:*/ false));
         }
 
@@ -1832,7 +1824,7 @@ module TypeScript.Parser {
                 finallyClause = parseFinallyClause();
             }
 
-            return new syntaxFactory.TryStatementSyntax(parseNodeData, tryKeyword, block, catchClause, finallyClause);
+            return new TryStatementSyntax(parseNodeData, tryKeyword, block, catchClause, finallyClause);
         }
 
         function parseCatchClauseBlock(): BlockSyntax {
@@ -1845,23 +1837,23 @@ module TypeScript.Parser {
         }
 
         function parseCatchClause(): CatchClauseSyntax {
-            return new syntaxFactory.CatchClauseSyntax(parseNodeData,
+            return new CatchClauseSyntax(parseNodeData,
                 eatToken(SyntaxKind.CatchKeyword), eatToken(SyntaxKind.OpenParenToken), eatIdentifierToken(),
                 parseOptionalTypeAnnotation(/*allowStringLiteral:*/ false), eatToken(SyntaxKind.CloseParenToken), parseCatchClauseBlock());
         }
 
         function parseFinallyClause(): FinallyClauseSyntax {
-            return new syntaxFactory.FinallyClauseSyntax(parseNodeData,
+            return new FinallyClauseSyntax(parseNodeData,
                 eatToken(SyntaxKind.FinallyKeyword), parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, /*checkForStrictMode:*/ false));
         }
 
         function parseWithStatement(withKeyword: ISyntaxToken): WithStatementSyntax {
-            return new syntaxFactory.WithStatementSyntax(parseNodeData,
+            return new WithStatementSyntax(parseNodeData,
                 consumeToken(withKeyword), eatToken(SyntaxKind.OpenParenToken), parseExpression(/*allowIn:*/ true), eatToken(SyntaxKind.CloseParenToken), parseStatement(/*inErrorRecovery:*/ false));
         }
 
         function parseWhileStatement(whileKeyword: ISyntaxToken): WhileStatementSyntax {
-            return new syntaxFactory.WhileStatementSyntax(parseNodeData,
+            return new WhileStatementSyntax(parseNodeData,
                 consumeToken(whileKeyword), eatToken(SyntaxKind.OpenParenToken), parseExpression(/*allowIn:*/ true), eatToken(SyntaxKind.CloseParenToken), parseStatement(/*inErrorRecovery:*/ false));
         }
 
@@ -1880,7 +1872,7 @@ module TypeScript.Parser {
         }
 
         function parseEmptyStatement(semicolonToken: ISyntaxToken): EmptyStatementSyntax {
-            return new syntaxFactory.EmptyStatementSyntax(parseNodeData, consumeToken(semicolonToken));
+            return new EmptyStatementSyntax(parseNodeData, consumeToken(semicolonToken));
         }
 
         function parseForOrForInStatement(forKeyword: ISyntaxToken): IStatementSyntax {
@@ -1923,7 +1915,7 @@ module TypeScript.Parser {
         function parseForInStatementWithVariableDeclarationOrInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax): ForInStatementSyntax {
             // for ( var VariableDeclarationNoIn in Expression ) Statement
 
-            return new syntaxFactory.ForInStatementSyntax(parseNodeData,
+            return new ForInStatementSyntax(parseNodeData,
                 forKeyword, openParenToken, variableDeclaration, initializer, eatToken(SyntaxKind.InKeyword),
                 parseExpression(/*allowIn:*/ true), eatToken(SyntaxKind.CloseParenToken), parseStatement(/*inErrorRecovery:*/ false));
         }
@@ -1974,7 +1966,7 @@ module TypeScript.Parser {
             // a semicolon is never inserted automatically if the semicolon would then ... become 
             // one of the two semicolons in the header of a for statement
 
-            return new syntaxFactory.ForStatementSyntax(parseNodeData,
+            return new ForStatementSyntax(parseNodeData,
                 forKeyword, openParenToken, variableDeclaration, initializer,
                 eatToken(SyntaxKind.SemicolonToken), tryParseForStatementCondition(),
                 eatToken(SyntaxKind.SemicolonToken), tryParseForStatementIncrementor(),
@@ -1995,12 +1987,12 @@ module TypeScript.Parser {
         }
 
         function parseBreakStatement(breakKeyword: ISyntaxToken): BreakStatementSyntax {
-            return new syntaxFactory.BreakStatementSyntax(parseNodeData,
+            return new BreakStatementSyntax(parseNodeData,
                 consumeToken(breakKeyword), tryEatBreakOrContinueLabel(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
         function parseContinueStatement(continueKeyword: ISyntaxToken): ContinueStatementSyntax {
-            return new syntaxFactory.ContinueStatementSyntax(parseNodeData,
+            return new ContinueStatementSyntax(parseNodeData,
                 consumeToken(continueKeyword), tryEatBreakOrContinueLabel(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
@@ -2020,7 +2012,7 @@ module TypeScript.Parser {
                 openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
             }
 
-            return new syntaxFactory.SwitchStatementSyntax(parseNodeData, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, eatToken(SyntaxKind.CloseBraceToken));
+            return new SwitchStatementSyntax(parseNodeData, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function isSwitchClause(): boolean {
@@ -2069,7 +2061,7 @@ module TypeScript.Parser {
                 colonToken = addSkippedTokensAfterToken(colonToken, skippedTokens);
             }
 
-            return new syntaxFactory.CaseSwitchClauseSyntax(parseNodeData, caseKeyword, expression, colonToken, statements);
+            return new CaseSwitchClauseSyntax(parseNodeData, caseKeyword, expression, colonToken, statements);
         }
 
         function parseDefaultSwitchClause(defaultKeyword: ISyntaxToken): DefaultSwitchClauseSyntax {
@@ -2087,7 +2079,7 @@ module TypeScript.Parser {
                 colonToken = addSkippedTokensAfterToken(colonToken, skippedTokens);
             }
 
-            return new syntaxFactory.DefaultSwitchClauseSyntax(parseNodeData, defaultKeyword, colonToken, statements);
+            return new DefaultSwitchClauseSyntax(parseNodeData, defaultKeyword, colonToken, statements);
         }
 
         function parseThrowStatementExpression(): IExpressionSyntax {
@@ -2100,7 +2092,7 @@ module TypeScript.Parser {
         }
 
         function parseThrowStatement(throwKeyword: ISyntaxToken): ThrowStatementSyntax {
-            return new syntaxFactory.ThrowStatementSyntax(parseNodeData,
+            return new ThrowStatementSyntax(parseNodeData,
                 consumeToken(throwKeyword), parseThrowStatementExpression(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
@@ -2109,7 +2101,7 @@ module TypeScript.Parser {
         }
 
         function parseReturnStatement(returnKeyword: ISyntaxToken): ReturnStatementSyntax {
-            return new syntaxFactory.ReturnStatementSyntax(parseNodeData,
+            return new ReturnStatementSyntax(parseNodeData,
                 consumeToken(returnKeyword), tryParseReturnStatementExpression(), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
@@ -2128,7 +2120,7 @@ module TypeScript.Parser {
             // Debug.assert(isAssignmentOrOmittedExpression());
 
             if (currentToken().kind() === SyntaxKind.CommaToken) {
-                return new syntaxFactory.OmittedExpressionSyntax(parseNodeData);
+                return new OmittedExpressionSyntax(parseNodeData);
             }
 
             return tryParseAssignmentExpressionOrHigher(/*force:*/ false, /*allowIn:*/ true);
@@ -2202,11 +2194,11 @@ module TypeScript.Parser {
         }
 
         function parseExpressionStatement(): ExpressionStatementSyntax {
-            return new syntaxFactory.ExpressionStatementSyntax(parseNodeData, parseExpression(/*allowIn:*/ true), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
+            return new ExpressionStatementSyntax(parseNodeData, parseExpression(/*allowIn:*/ true), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
         function parseIfStatement(ifKeyword: ISyntaxToken): IfStatementSyntax {
-            return new syntaxFactory.IfStatementSyntax(parseNodeData,
+            return new IfStatementSyntax(parseNodeData,
                 consumeToken(ifKeyword), eatToken(SyntaxKind.OpenParenToken), parseExpression(/*allowIn:*/ true),
                 eatToken(SyntaxKind.CloseParenToken), parseStatement(/*inErrorRecovery:*/ false), parseOptionalElseClause());
         }
@@ -2216,7 +2208,7 @@ module TypeScript.Parser {
         }
 
         function parseElseClause(): ElseClauseSyntax {
-            return new syntaxFactory.ElseClauseSyntax(parseNodeData, eatToken(SyntaxKind.ElseKeyword), parseStatement(/*inErrorRecovery:*/ false));
+            return new ElseClauseSyntax(parseNodeData, eatToken(SyntaxKind.ElseKeyword), parseStatement(/*inErrorRecovery:*/ false));
         }
 
         function isVariableStatement(modifierCount: number): boolean {
@@ -2224,7 +2216,7 @@ module TypeScript.Parser {
         }
 
         function parseVariableStatement(): VariableStatementSyntax {
-            return new syntaxFactory.VariableStatementSyntax(parseNodeData,
+            return new VariableStatementSyntax(parseNodeData,
                 parseModifiers(), parseVariableDeclaration(/*allowIn:*/ true), eatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false));
         }
 
@@ -2242,7 +2234,7 @@ module TypeScript.Parser {
             var variableDeclarators = parseSeparatedSyntaxList<VariableDeclaratorSyntax>(listParsingState, skippedTokens);
             varKeyword = addSkippedTokensAfterToken(varKeyword, skippedTokens);
 
-            return new syntaxFactory.VariableDeclarationSyntax(parseNodeData, varKeyword, variableDeclarators);
+            return new VariableDeclarationSyntax(parseNodeData, varKeyword, variableDeclarators);
         }
 
         function isVariableDeclarator(): boolean {
@@ -2310,7 +2302,7 @@ module TypeScript.Parser {
                 }
             }
 
-            return new syntaxFactory.VariableDeclaratorSyntax(parseNodeData, propertyName, typeAnnotation, equalsValueClause);
+            return new VariableDeclaratorSyntax(parseNodeData, propertyName, typeAnnotation, equalsValueClause);
         }
 
         function isEqualsValueClause(inParameter: boolean): boolean {
@@ -2351,7 +2343,7 @@ module TypeScript.Parser {
         }
 
         function parseEqualsValueClause(allowIn: boolean): EqualsValueClauseSyntax {
-            return new syntaxFactory.EqualsValueClauseSyntax(parseNodeData,
+            return new EqualsValueClauseSyntax(parseNodeData,
                 eatToken(SyntaxKind.EqualsToken), tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn));
         }
 
@@ -2367,7 +2359,7 @@ module TypeScript.Parser {
                     break;
                 }
 
-                leftOperand = new syntaxFactory.BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(_currentToken), 
+                leftOperand = new BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(_currentToken), 
                     tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn));
             }
 
@@ -2431,7 +2423,7 @@ module TypeScript.Parser {
 
                 // Check for recursive assignment expressions.
                 if (SyntaxFacts.isAssignmentOperatorToken(operatorToken.kind())) {
-                    return new syntaxFactory.BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(operatorToken), 
+                    return new BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(operatorToken), 
                         tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn));
                 }
             }
@@ -2456,7 +2448,7 @@ module TypeScript.Parser {
                 case SyntaxKind.ExclamationToken:
                 case SyntaxKind.PlusPlusToken:
                 case SyntaxKind.MinusMinusToken:
-                    return new syntaxFactory.PrefixUnaryExpressionSyntax(parseNodeData, consumeToken(_currentToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
+                    return new PrefixUnaryExpressionSyntax(parseNodeData, consumeToken(_currentToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
                 case SyntaxKind.TypeOfKeyword: return parseTypeOfExpression(_currentToken);
                 case SyntaxKind.VoidKeyword:   return parseVoidExpression(_currentToken);
                 case SyntaxKind.DeleteKeyword: return parseDeleteExpression(_currentToken);
@@ -2496,7 +2488,7 @@ module TypeScript.Parser {
             // Note: we explicitly do *not* pass 'allowIn' to the whenTrue part.  An 'in' expression is always
             // allowed in the 'true' part of a conditional expression.
 
-            return new syntaxFactory.ConditionalExpressionSyntax(parseNodeData,
+            return new ConditionalExpressionSyntax(parseNodeData,
                 leftOperand, consumeToken(_currentToken), tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true),
                 eatToken(SyntaxKind.ColonToken), tryParseAssignmentExpressionOrHigher(/*force:*/ true, allowIn));
         }
@@ -2537,7 +2529,7 @@ module TypeScript.Parser {
                 // Precedence is okay, so we'll "take" this operator.
                 // Now skip the operator token we're on.
 
-                leftOperand = new syntaxFactory.BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(operatorToken), 
+                leftOperand = new BinaryExpressionSyntax(parseNodeData, leftOperand, consumeToken(operatorToken), 
                     tryParseBinaryExpressionOrHigher(currentToken(), /*force:*/ true, newPrecedence, allowIn));
             }
 
@@ -2623,7 +2615,7 @@ module TypeScript.Parser {
 
                 switch (currentTokenKind) {
                     case SyntaxKind.OpenParenToken:
-                        expression = new syntaxFactory.InvocationExpressionSyntax(parseNodeData, expression, parseArgumentList(/*typeArgumentList:*/ undefined));
+                        expression = new InvocationExpressionSyntax(parseNodeData, expression, parseArgumentList(/*typeArgumentList:*/ undefined));
                         continue;
 
                     case SyntaxKind.LessThanToken:
@@ -2636,7 +2628,7 @@ module TypeScript.Parser {
                             break;
                         }
 
-                        expression = new syntaxFactory.InvocationExpressionSyntax(parseNodeData, expression, argumentList);
+                        expression = new InvocationExpressionSyntax(parseNodeData, expression, argumentList);
                         continue;
 
                     case SyntaxKind.OpenBracketToken:
@@ -2644,7 +2636,7 @@ module TypeScript.Parser {
                         continue;
 
                     case SyntaxKind.DotToken:
-                        expression = new syntaxFactory.MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken());
+                        expression = new MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken());
                         continue;
                 }
 
@@ -2663,7 +2655,7 @@ module TypeScript.Parser {
                         continue;
 
                     case SyntaxKind.DotToken:
-                        expression = new syntaxFactory.MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken());
+                        expression = new MemberAccessExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken), eatIdentifierNameToken());
                         continue;
                 }
 
@@ -2727,7 +2719,7 @@ module TypeScript.Parser {
             var currentTokenKind = currentToken().kind();
             return currentTokenKind === SyntaxKind.OpenParenToken || currentTokenKind === SyntaxKind.DotToken
                 ? expression
-                : new syntaxFactory.MemberAccessExpressionSyntax(parseNodeData, expression, eatToken(SyntaxKind.DotToken), eatIdentifierNameToken());
+                : new MemberAccessExpressionSyntax(parseNodeData, expression, eatToken(SyntaxKind.DotToken), eatIdentifierNameToken());
         }
 
         function tryParsePostfixExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IPostfixExpressionSyntax {
@@ -2748,7 +2740,7 @@ module TypeScript.Parser {
                         break;
                     }
 
-                    return new syntaxFactory.PostfixUnaryExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken));
+                    return new PostfixUnaryExpressionSyntax(parseNodeData, expression, consumeToken(_currentToken));
             }
 
             return expression;
@@ -2790,7 +2782,7 @@ module TypeScript.Parser {
                         DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, undefined);
                     addDiagnostic(diagnostic);
 
-                    return new syntaxFactory.ArgumentListSyntax(parseNodeData, typeArgumentList,
+                    return new ArgumentListSyntax(parseNodeData, typeArgumentList,
                         Syntax.emptyToken(SyntaxKind.OpenParenToken), Syntax.emptySeparatedList<IExpressionSyntax>(), Syntax.emptyToken(SyntaxKind.CloseParenToken));
                 }
                 else {
@@ -2824,7 +2816,7 @@ module TypeScript.Parser {
                 openParenToken = addSkippedTokensAfterToken(openParenToken, skippedTokens);
             }
 
-            return new syntaxFactory.ArgumentListSyntax(parseNodeData, typeArgumentList, openParenToken, _arguments, eatToken(SyntaxKind.CloseParenToken));
+            return new ArgumentListSyntax(parseNodeData, typeArgumentList, openParenToken, _arguments, eatToken(SyntaxKind.CloseParenToken));
         }
 
         function tryParseArgumentListExpression(): IExpressionSyntax {
@@ -2858,7 +2850,7 @@ module TypeScript.Parser {
 
         function parseElementAccessExpression(expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, inObjectCreation: boolean): ElementAccessExpressionSyntax {
             // Debug.assert(currentToken().kind() === SyntaxKind.OpenBracketToken);
-            return new syntaxFactory.ElementAccessExpressionSyntax(parseNodeData, expression, consumeToken(openBracketToken),
+            return new ElementAccessExpressionSyntax(parseNodeData, expression, consumeToken(openBracketToken),
                 parseElementAccessArgumentExpression(openBracketToken, inObjectCreation), eatToken(SyntaxKind.CloseBracketToken));
         }
 
@@ -2937,19 +2929,19 @@ module TypeScript.Parser {
         }
 
         function parseTypeOfExpression(typeOfKeyword: ISyntaxToken): TypeOfExpressionSyntax {
-            return new syntaxFactory.TypeOfExpressionSyntax(parseNodeData, consumeToken(typeOfKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
+            return new TypeOfExpressionSyntax(parseNodeData, consumeToken(typeOfKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
         }
 
         function parseDeleteExpression(deleteKeyword: ISyntaxToken): DeleteExpressionSyntax {
-            return new syntaxFactory.DeleteExpressionSyntax(parseNodeData, consumeToken(deleteKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
+            return new DeleteExpressionSyntax(parseNodeData, consumeToken(deleteKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
         }
 
         function parseVoidExpression(voidKeyword: ISyntaxToken): VoidExpressionSyntax {
-            return new syntaxFactory.VoidExpressionSyntax(parseNodeData, consumeToken(voidKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
+            return new VoidExpressionSyntax(parseNodeData, consumeToken(voidKeyword), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
         }
 
         function parseFunctionExpression(functionKeyword: ISyntaxToken): FunctionExpressionSyntax {
-            return new syntaxFactory.FunctionExpressionSyntax(parseNodeData,
+            return new FunctionExpressionSyntax(parseNodeData,
                 consumeToken(functionKeyword), eatOptionalIdentifierToken(),
                 parseCallSignature(/*requireCompleteTypeParameterList:*/ false),
                 parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, /*checkForStrictMode:*/ true));
@@ -2965,17 +2957,17 @@ module TypeScript.Parser {
             // See comment in tryParseMemberExpressionOrHigher for a more complete explanation of
             // this decision.
 
-            return new syntaxFactory.ObjectCreationExpressionSyntax(parseNodeData,
+            return new ObjectCreationExpressionSyntax(parseNodeData,
                 consumeToken(newKeyword), tryParseMemberExpressionOrHigher(currentToken(), /*force:*/ true, /*inObjectCreation:*/ true), tryParseArgumentList());
         }
 
         function parseCastExpression(lessThanToken: ISyntaxToken): CastExpressionSyntax {
-            return new syntaxFactory.CastExpressionSyntax(parseNodeData,
+            return new CastExpressionSyntax(parseNodeData,
                 consumeToken(lessThanToken), parseType(), eatToken(SyntaxKind.GreaterThanToken), tryParseUnaryExpressionOrHigher(currentToken(), /*force:*/ true));
         }
 
         function parseParenthesizedExpression(openParenToken: ISyntaxToken): ParenthesizedExpressionSyntax {
-            return new syntaxFactory.ParenthesizedExpressionSyntax(parseNodeData,
+            return new ParenthesizedExpressionSyntax(parseNodeData,
                 consumeToken(openParenToken), parseExpression(/*allowIn:*/ true), eatToken(SyntaxKind.CloseParenToken));
         }
 
@@ -3036,7 +3028,7 @@ module TypeScript.Parser {
                 expression = tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true);
             }
 
-            return new syntaxFactory.ParenthesizedArrowFunctionExpressionSyntax(parseNodeData, callSignature, equalsGreaterThanToken, block, expression);
+            return new ParenthesizedArrowFunctionExpressionSyntax(parseNodeData, callSignature, equalsGreaterThanToken, block, expression);
         }
 
         function tryParseArrowFunctionBlock(): BlockSyntax {
@@ -3092,7 +3084,7 @@ module TypeScript.Parser {
                 expression = tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true);
             }
 
-            return new syntaxFactory.SimpleArrowFunctionExpressionSyntax(parseNodeData, parameter, equalsGreaterThanToken, block, expression);
+            return new SimpleArrowFunctionExpressionSyntax(parseNodeData, parameter, equalsGreaterThanToken, block, expression);
         }
 
         function isBlock(): boolean {
@@ -3268,7 +3260,7 @@ module TypeScript.Parser {
             var propertyAssignments = parseSeparatedSyntaxList<IPropertyAssignmentSyntax>(ListParsingState.ObjectLiteralExpression_PropertyAssignments, skippedTokens);
             openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
 
-            return new syntaxFactory.ObjectLiteralExpressionSyntax(parseNodeData, openBraceToken, propertyAssignments, eatToken(SyntaxKind.CloseBraceToken));
+            return new ObjectLiteralExpressionSyntax(parseNodeData, openBraceToken, propertyAssignments, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function tryParsePropertyAssignment(inErrorRecovery: boolean): IPropertyAssignmentSyntax {
@@ -3307,7 +3299,7 @@ module TypeScript.Parser {
         }
 
         function parseFunctionPropertyAssignment(): FunctionPropertyAssignmentSyntax {
-            return new syntaxFactory.FunctionPropertyAssignmentSyntax(parseNodeData,
+            return new FunctionPropertyAssignmentSyntax(parseNodeData,
                 eatPropertyName(), parseCallSignature(/*requireCompleteTypeParameterList:*/ false),
                 parseBlock(/*parseBlockEvenWithNoOpenBrace:*/ false, /*checkForStrictMode:*/ true));
         }
@@ -3317,7 +3309,7 @@ module TypeScript.Parser {
         }
 
         function parseSimplePropertyAssignment(): SimplePropertyAssignmentSyntax {
-            return new syntaxFactory.SimplePropertyAssignmentSyntax(parseNodeData,
+            return new SimplePropertyAssignmentSyntax(parseNodeData,
                 eatPropertyName(), eatToken(SyntaxKind.ColonToken), tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true));
         }
 
@@ -3353,7 +3345,7 @@ module TypeScript.Parser {
             var expressions = parseSeparatedSyntaxList<IExpressionSyntax>(ListParsingState.ArrayLiteralExpression_AssignmentExpressions, skippedTokens);
             openBracketToken = addSkippedTokensAfterToken(openBracketToken, skippedTokens);
 
-            return new syntaxFactory.ArrayLiteralExpressionSyntax(parseNodeData, openBracketToken, expressions, eatToken(SyntaxKind.CloseBracketToken));
+            return new ArrayLiteralExpressionSyntax(parseNodeData, openBracketToken, expressions, eatToken(SyntaxKind.CloseBracketToken));
         }
 
         function parseBlock(parseBlockEvenWithNoOpenBrace: boolean, checkForStrictMode: boolean): BlockSyntax {
@@ -3371,11 +3363,11 @@ module TypeScript.Parser {
                 setStrictMode(savedIsInStrictMode);
             }
 
-            return new syntaxFactory.BlockSyntax(parseNodeData, openBraceToken, statements, eatToken(SyntaxKind.CloseBraceToken));
+            return new BlockSyntax(parseNodeData, openBraceToken, statements, eatToken(SyntaxKind.CloseBraceToken));
         }
 
         function parseCallSignature(requireCompleteTypeParameterList: boolean): CallSignatureSyntax {
-            return new syntaxFactory.CallSignatureSyntax(parseNodeData,
+            return new CallSignatureSyntax(parseNodeData,
                 tryParseTypeParameterList(requireCompleteTypeParameterList), parseParameterList(), parseOptionalTypeAnnotation(/*allowStringLiteral:*/ false));
         }
 
@@ -3403,7 +3395,7 @@ module TypeScript.Parser {
             }
             else {
                 releaseRewindPoint(rewindPoint);
-                return new syntaxFactory.TypeParameterListSyntax(parseNodeData, lessThanToken, typeParameters, greaterThanToken);
+                return new TypeParameterListSyntax(parseNodeData, lessThanToken, typeParameters, greaterThanToken);
             }
         }
 
@@ -3417,7 +3409,7 @@ module TypeScript.Parser {
                 return undefined;
             }
 
-            return new syntaxFactory.TypeParameterSyntax(parseNodeData, eatIdentifierToken(), tryParseConstraint());
+            return new TypeParameterSyntax(parseNodeData, eatIdentifierToken(), tryParseConstraint());
         }
 
         function tryParseConstraint(): ConstraintSyntax {
@@ -3425,7 +3417,7 @@ module TypeScript.Parser {
                 return undefined;
             }
 
-            return new syntaxFactory.ConstraintSyntax(parseNodeData, eatToken(SyntaxKind.ExtendsKeyword), parseTypeOrExpression());
+            return new ConstraintSyntax(parseNodeData, eatToken(SyntaxKind.ExtendsKeyword), parseTypeOrExpression());
         }
 
         function tryParseParameterList(): ParameterListSyntax {
@@ -3450,7 +3442,7 @@ module TypeScript.Parser {
                 openParenToken = addSkippedTokensAfterToken(openParenToken, skippedTokens);
             }
 
-            return new syntaxFactory.ParameterListSyntax(parseNodeData, openParenToken, parameters, eatToken(SyntaxKind.CloseParenToken));
+            return new ParameterListSyntax(parseNodeData, openParenToken, parameters, eatToken(SyntaxKind.CloseParenToken));
         }
 
         function parseOptionalTypeAnnotation(allowStringLiteral: boolean): TypeAnnotationSyntax {
@@ -3469,7 +3461,7 @@ module TypeScript.Parser {
         }
 
         function parseTypeAnnotation(allowStringLiteral: boolean): TypeAnnotationSyntax {
-            return new syntaxFactory.TypeAnnotationSyntax(parseNodeData, consumeToken(currentToken()), parseTypeAnnotationType(allowStringLiteral));
+            return new TypeAnnotationSyntax(parseNodeData, consumeToken(currentToken()), parseTypeAnnotationType(allowStringLiteral));
         }
 
         function isType(): boolean {
@@ -3539,7 +3531,7 @@ module TypeScript.Parser {
                     consumeToken(barToken);
                     var right = parsePrimaryType();
 
-                    type = new syntaxFactory.UnionTypeSyntax(parseNodeData, type, barToken, right);
+                    type = new UnionTypeSyntax(parseNodeData, type, barToken, right);
                 } 
             }
 
@@ -3567,14 +3559,14 @@ module TypeScript.Parser {
                     break;
                 }
 
-                type = new syntaxFactory.ArrayTypeSyntax(parseNodeData, type, consumeToken(_currentToken), eatToken(SyntaxKind.CloseBracketToken));
+                type = new ArrayTypeSyntax(parseNodeData, type, consumeToken(_currentToken), eatToken(SyntaxKind.CloseBracketToken));
             }
 
             return type;
         }
 
         function parseTypeQuery(typeOfKeyword: ISyntaxToken): TypeQuerySyntax {
-            return new syntaxFactory.TypeQuerySyntax(parseNodeData, consumeToken(typeOfKeyword), parseName(/*allowIdentifierNames:*/ true));
+            return new TypeQuerySyntax(parseNodeData, consumeToken(typeOfKeyword), parseName(/*allowIdentifierNames:*/ true));
         }
 
         function tryParseNonArrayType(): ITypeSyntax {
@@ -3602,7 +3594,7 @@ module TypeScript.Parser {
         }
 
         function parseParenthesizedType(openParenToken: ISyntaxToken): ParenthesizedTypeSyntax {
-            return new syntaxFactory.ParenthesizedTypeSyntax(parseNodeData, consumeToken(openParenToken), parseType(), eatToken(SyntaxKind.CloseParenToken));
+            return new ParenthesizedTypeSyntax(parseNodeData, consumeToken(openParenToken), parseType(), eatToken(SyntaxKind.CloseParenToken));
         }
 
         function tryParseNameOrGenericType(): ITypeSyntax {
@@ -3622,7 +3614,7 @@ module TypeScript.Parser {
             var typeArgumentList = tryParseTypeArgumentList(/*inExpression:*/ false);
             return !typeArgumentList
                 ? name
-                : new syntaxFactory.GenericTypeSyntax(parseNodeData, name, typeArgumentList);
+                : new GenericTypeSyntax(parseNodeData, name, typeArgumentList);
         }
 
         function isFunctionType(): boolean {
@@ -3691,12 +3683,12 @@ module TypeScript.Parser {
             var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
             var parameterList = parseParameterList();
 
-            return new syntaxFactory.FunctionTypeSyntax(parseNodeData,
+            return new FunctionTypeSyntax(parseNodeData,
                 typeParameterList, parameterList, eatToken(SyntaxKind.EqualsGreaterThanToken), parseType());
         }
 
         function parseConstructorType(): ConstructorTypeSyntax {
-            return new syntaxFactory.ConstructorTypeSyntax(parseNodeData,
+            return new ConstructorTypeSyntax(parseNodeData,
                 eatToken(SyntaxKind.NewKeyword), tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false),
                 parseParameterList(), eatToken(SyntaxKind.EqualsGreaterThanToken), parseType());
         }
@@ -3717,7 +3709,7 @@ module TypeScript.Parser {
         }
 
         function eatSimpleParameter() {
-            return new syntaxFactory.ParameterSyntax(parseNodeData,
+            return new ParameterSyntax(parseNodeData,
                 /*dotDotDotToken:*/ undefined, /*modifiers:*/ Syntax.emptyList<ISyntaxToken>(), eatIdentifierToken(),
                 /*questionToken:*/ undefined, /*typeAnnotation:*/ undefined, /*equalsValueClause:*/ undefined);
         }
@@ -3757,7 +3749,7 @@ module TypeScript.Parser {
                 equalsValueClause = parseEqualsValueClause(/*allowIn:*/ true);
             }
 
-            return new syntaxFactory.ParameterSyntax(parseNodeData, dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause);
+            return new ParameterSyntax(parseNodeData, dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause);
         }
 
         function parseSyntaxList<T extends ISyntaxNodeOrToken>(
@@ -3810,30 +3802,27 @@ module TypeScript.Parser {
             // Continue parsing this list.  Attach this token to whatever we've seen already.
             return false;
         }
-        
+
         function addSkippedTokenToList(
-                nodesAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void {
+            nodesAndSeparators: ISyntaxNodeOrToken[], skippedTokens: ISyntaxToken[], skippedToken: ISyntaxToken): void {
             // Now, add this skipped token to the last item we successfully parsed in the list.  Or
             // add it to the list of skipped tokens if we haven't parsed anything.  Our caller will
             // have to deal with them.
             //
-            // Note: we only bother doing this if we're creating a concrete syntax tree.
-            if (syntaxFactory.isConcrete) {
-                var length = nodesAndSeparators.length;
-
-                for (var i = length - 1; i >= 0; i--) {
-                    var item = nodesAndSeparators[i];
-                    var _lastToken = lastToken(item);
-                    if (_lastToken && _lastToken.fullWidth() > 0) {
-                        nodesAndSeparators[i] = addSkippedTokenAfterNodeOrToken(item, skippedToken);
-                        return;
-                    }
-                }
+            var length = nodesAndSeparators.length;
 
-                // Didn't have anything in the list we could add to.  Add to the skipped items array
-                // for our caller to handle.
-                skippedTokens.push(skippedToken);
+            for (var i = length - 1; i >= 0; i--) {
+                var item = nodesAndSeparators[i];
+                var _lastToken = lastToken(item);
+                if (_lastToken && _lastToken.fullWidth() > 0) {
+                    nodesAndSeparators[i] = addSkippedTokenAfterNodeOrToken(item, skippedToken);
+                    return;
+                }
             }
+
+            // Didn't have anything in the list we could add to.  Add to the skipped items array
+            // for our caller to handle.
+            skippedTokens.push(skippedToken);
         }
 
         function tryParseExpectedListItem(
diff --git a/src/services/syntax/references.ts b/src/services/syntax/references.ts
index a4eb9efc5959c..84f7680103e1f 100644
--- a/src/services/syntax/references.ts
+++ b/src/services/syntax/references.ts
@@ -19,7 +19,6 @@
 ///<reference path='syntaxList.ts' />
 ///<reference path='syntaxNode.ts' />
 ///<reference path='syntaxNodeOrToken.ts' />
-///<reference path='syntaxNodes.interfaces.generated.ts' />
 
 // SyntaxDedenter depends on SyntaxRewriter
 // ///<reference path='syntaxDedenter.ts' />
diff --git a/src/services/syntax/syntaxGenerator.ts b/src/services/syntax/syntaxGenerator.ts
index 8b9008dcdfc41..abd964d108c1f 100644
--- a/src/services/syntax/syntaxGenerator.ts
+++ b/src/services/syntax/syntaxGenerator.ts
@@ -2036,49 +2036,7 @@ function generateSyntaxInterfaces(): string {
         result += generateSyntaxInterface(definition);
     }
 
-    result += "\r\n\r\n";
-
-    /*
-    result += "    export var nodeMetadata: string[][] = [";
-    for (var i = 0; i <= TypeScript.SyntaxKind.LastNode; i++) {
-        if (i < TypeScript.SyntaxKind.FirstNode) {
-            result += "[],";
-            continue;
-        }
-
-        var kindName = syntaxKindName(i);
-
-        var definition = getDefinitionForKind(i);
-
-        var metadata = "[";
-        var children = definition.children.filter(m => m.type !== "SyntaxKind").map(m => '"' + m.name + '"');
-        metadata += children.join(",");
-        metadata += "],";
-
-        result += metadata;
-    }
-    result += "];\r\n\r\n";
-    */
-
-    result += "    export module Syntax {\r\n"
-
-    result += "        export interface ISyntaxFactory {\r\n";
-    result += "            isConcrete: boolean;\r\n";
-
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-        result += "            " + definition.name + ": { new(data: number";
-
-        for (var j = 0; j < definition.children.length; j++) {
-            var child = definition.children[j];
-            result += ", " + child.name + ": " + getType(child);
-        }
-
-        result += "): " + definition.name + " };\r\n";
-    }
-
-    result += "        }\r\n";
-    result += "    }\r\n";
+    result += "\r\n";
 
     result += "}";
     return result;
@@ -2112,16 +2070,9 @@ function generateSyntaxInterface(definition: ITypeDefinition): string {
 function generateNodes(abstract: boolean): string {
     var result = "///<reference path='references.ts' />\r\n\r\n";
 
-    result += "module TypeScript.Syntax.";
-
-    var moduleName = abstract ? "Abstract" : "Concrete";
-    result += moduleName;
+    result += "module TypeScript";
 
     result += " {\r\n";
-    result += "    // Inject this module as the factory for producing syntax nodes in the parser.\r\n";
-    result += "    Parser.syntaxFactory = " + moduleName + ";\r\n";
-    result += "    export var isConcrete: boolean = " + !abstract + ";\r\n\r\n";
-
     for (var i = 0; i < definitions.length; i++) {
         var definition = definitions[i];
 
@@ -2131,24 +2082,6 @@ function generateNodes(abstract: boolean): string {
 
         result += generateNode(definition, abstract);
     }
-    /*
-    result += "\r\n\r\n    ";
-
-    for (var i = 0; i < definitions.length; i++) {
-        var definition = definitions[i];
-
-        if (definition.syntaxKinds) {
-            continue;
-        }
-
-        if (i) {
-            result += ", "
-        }
-
-        result += "(<any>" + definition.name + ").prototype.__kind = SyntaxKind." + getNameWithoutSuffix(definition)
-    }
-
-    result += ";\r\n";*/
 
     result += "\r\n}";
     return result;
@@ -2834,7 +2767,6 @@ var defaultVisitor = generateDefaultVisitor();
 var servicesUtilities = generateServicesUtilities();
 
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.concrete.generated.ts", syntaxNodesConcrete, false);
-sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxNodes.interfaces.generated.ts", syntaxInterfaces, false);
 sys.writeFile(sys.getCurrentDirectory() + "\\src\\services\\syntax\\syntaxRewriter.generated.ts", rewriter, 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);
diff --git a/src/services/syntax/syntaxInterfaces.generated.ts b/src/services/syntax/syntaxInterfaces.generated.ts
deleted file mode 100644
index b7f99f68b288a..0000000000000
--- a/src/services/syntax/syntaxInterfaces.generated.ts
+++ /dev/null
@@ -1,499 +0,0 @@
-///<reference path='references.ts' />
-
-module TypeScript {
-    export enum NodeFlags {
-        Export   = 0x00000001,  // Declarations
-        Ambient  = 0x00000002,  // Declarations
-        Optional = 0x00000004,  // Parameter/Property/Method
-        Rest     = 0x00000008,  // Parameter
-        Public   = 0x00000010,  // Property/Method
-        Private  = 0x00000020,  // Property/Method
-        Static   = 0x00000040,  // Property/Method
-    }
-
-    interface SyntaxElement {
-        kind: SyntaxKind;
-    }
-
-    interface SyntaxNode extends SyntaxElement {
-        flags: NodeFlags;
-    }
-
-    function nodeStart(node: Node): number {
-    }
-
-    function nodeWidth(node: Node): number {
-    }
-
-    interface SyntaxToken extends Name, PrimaryExpression {
-    }
-
-    // The raw text of the token, as written in the original source.
-    function tokenText(token: SyntaxToken): string {
-    }
-
-    // The token's javascript value.  i.e. 0.0 in the text would have the javascript number value: 0.
-    function tokenValue(token: SyntaxToken): any {
-    }
-
-    // The token's value in string form.  i.e. \u0041 in the source text would result in a string with the text: A.
-    function tokenValueText(token: SyntaxToken): string {
-    }
-
-    interface SyntaxList<T> extends SyntaxElement {
-        length: number;
-        item(index: number): T;
-    }
-
-    interface SourceUnit extends Node {
-        moduleElements: SyntaxList<ModuleElement>;
-    }
-
-    interface QualifiedName extends Name {
-        left: Name;
-        right: SyntaxToken;
-    }
-
-    interface ObjectType extends Type {
-        typeMembers: SyntaxList<TypeMember>;
-    }
-
-    interface FunctionType extends Type {
-        typeParameterList?: TypeParameterList;
-        parameterList: ParameterList;
-        type: Type;
-    }
-
-    interface ArrayType extends Type {
-        type: Type;
-    }
-
-    interface ConstructorType extends Type {
-        typeParameterList?: TypeParameterList;
-        parameterList: ParameterList;
-        type: Type;
-    }
-
-    interface GenericType extends Type {
-        name: Name;
-        typeArgumentList: TypeArgumentList;
-    }
-
-    interface TypeQuery extends Type {
-        name: Name;
-    }
-
-    interface InterfaceDeclaration extends ModuleElement {
-        identifier: SyntaxToken;
-        typeParameterList?: TypeParameterList;
-        heritageClauses: SyntaxList<HeritageClause>;
-        body: ObjectType;
-    }
-
-    interface FunctionDeclaration extends Statement {
-        identifier: SyntaxToken;
-        callSignature: CallSignature;
-        block?: Block;
-    }
-
-    interface ModuleDeclaration extends ModuleElement {
-        name?: Name;
-        stringLiteral?: SyntaxToken;
-        moduleElements: SyntaxList<ModuleElement>;
-    }
-
-    interface ClassDeclaration extends ModuleElement {
-        identifier: SyntaxToken;
-        typeParameterList?: TypeParameterList;
-        heritageClauses: SyntaxList<HeritageClause>;
-        classElements: SyntaxList<ClassElement>;
-    }
-
-    interface EnumDeclaration extends ModuleElement {
-        identifier: SyntaxToken;
-        enumElements: SyntaxList<EnumElement>;
-    }
-
-    interface ImportDeclaration extends ModuleElement {
-        identifier: SyntaxToken;
-        moduleReference: ModuleReference;
-    }
-
-    interface ExportAssignment extends ModuleElement {
-        identifier: SyntaxToken;
-    }
-
-    interface MemberFunctionDeclaration extends MemberDeclaration {
-        propertyName: SyntaxToken;
-        callSignature: CallSignature;
-        block?: Block;
-    }
-
-    interface MemberVariableDeclaration extends MemberDeclaration {
-        variableDeclarator: VariableDeclarator;
-    }
-
-    interface ConstructorDeclaration extends ClassElement {
-        callSignature: CallSignature;
-        block?: Block;
-    }
-
-    interface IndexMemberDeclaration extends ClassElement {
-        indexSignature: IndexSignature;
-    }
-
-    interface GetAccessor extends MemberDeclaration, PropertyAssignment {
-        propertyName: SyntaxToken;
-        callSignature: CallSignature;
-        block: Block;
-    }
-
-    interface SetAccessor extends MemberDeclaration, PropertyAssignment {
-        propertyName: SyntaxToken;
-        callSignature: CallSignature;
-        block: Block;
-    }
-
-    interface PropertySignature extends TypeMember {
-        propertyName: SyntaxToken;
-        typeAnnotation?: TypeAnnotation;
-    }
-
-    interface CallSignature extends TypeMember {
-        typeParameterList?: TypeParameterList;
-        parameterList: ParameterList;
-        typeAnnotation?: TypeAnnotation;
-    }
-
-    interface ConstructSignature extends TypeMember {
-        callSignature: CallSignature;
-    }
-
-    interface IndexSignature extends TypeMember {
-        parameters: SyntaxList<Parameter>;
-        typeAnnotation?: TypeAnnotation;
-    }
-
-    interface MethodSignature extends TypeMember {
-        propertyName: SyntaxToken;
-        callSignature: CallSignature;
-    }
-
-    interface Block extends Statement {
-        statements: SyntaxList<Statement>;
-    }
-
-    interface IfStatement extends Statement {
-        condition: Expression;
-        statement: Statement;
-        elseClause?: ElseClause;
-    }
-
-    interface VariableStatement extends Statement {
-        variableDeclaration: VariableDeclaration;
-    }
-
-    interface ExpressionStatement extends Statement {
-        expression: Expression;
-    }
-
-    interface ReturnStatement extends Statement {
-        expression?: Expression;
-    }
-
-    interface SwitchStatement extends Statement {
-        expression: Expression;
-        switchClauses: SyntaxList<SwitchClause>;
-    }
-
-    interface BreakStatement extends Statement {
-        identifier?: SyntaxToken;
-    }
-
-    interface ContinueStatement extends Statement {
-        identifier?: SyntaxToken;
-    }
-
-    interface ForStatement extends Statement {
-        variableDeclaration?: VariableDeclaration;
-        initializer?: Expression;
-        condition?: Expression;
-        incrementor?: Expression;
-        statement: Statement;
-    }
-
-    interface ForInStatement extends Statement {
-        variableDeclaration?: VariableDeclaration;
-        left?: Expression;
-        expression: Expression;
-        statement: Statement;
-    }
-
-    interface ThrowStatement extends Statement {
-        expression: Expression;
-    }
-
-    interface WhileStatement extends Statement {
-        condition: Expression;
-        statement: Statement;
-    }
-
-    interface TryStatement extends Statement {
-        block: Block;
-        catchClause?: CatchClause;
-        finallyClause?: FinallyClause;
-    }
-
-    interface LabeledStatement extends Statement {
-        identifier: SyntaxToken;
-        statement: Statement;
-    }
-
-    interface DoStatement extends Statement {
-        statement: Statement;
-        condition: Expression;
-    }
-
-    interface WithStatement extends Statement {
-        condition: Expression;
-        statement: Statement;
-    }
-
-    interface PrefixUnaryExpression extends UnaryExpression {
-        operand: UnaryExpression;
-    }
-
-    interface DeleteExpression extends UnaryExpression {
-        expression: UnaryExpression;
-    }
-
-    interface TypeOfExpression extends UnaryExpression {
-        expression: UnaryExpression;
-    }
-
-    interface VoidExpression extends UnaryExpression {
-        expression: UnaryExpression;
-    }
-
-    interface ConditionalExpression extends Expression {
-        condition: Expression;
-        whenTrue: Expression;
-        whenFalse: Expression;
-    }
-
-    interface BinaryExpression extends Expression {
-        left: Expression;
-        right: Expression;
-    }
-
-    interface PostfixUnaryExpression extends PostfixExpression {
-        operand: LeftHandSideExpression;
-    }
-
-    interface MemberAccessExpression extends MemberExpression, CallExpression {
-        expression: LeftHandSideExpression;
-        name: SyntaxToken;
-    }
-
-    interface InvocationExpression extends CallExpression {
-        expression: LeftHandSideExpression;
-        argumentList: ArgumentList;
-    }
-
-    interface ArrayLiteralExpression extends PrimaryExpression {
-        expressions: SyntaxList<Expression>;
-    }
-
-    interface ObjectLiteralExpression extends PrimaryExpression {
-        propertyAssignments: SyntaxList<PropertyAssignment>;
-    }
-
-    interface ObjectCreationExpression extends MemberExpression {
-        expression: MemberExpression;
-        argumentList?: ArgumentList;
-    }
-
-    interface ParenthesizedExpression extends PrimaryExpression {
-        expression: Expression;
-    }
-
-    interface ParenthesizedArrowFunctionExpression extends UnaryExpression {
-        callSignature: CallSignature;
-        block?: Block;
-        expression?: Expression;
-    }
-
-    interface SimpleArrowFunctionExpression extends UnaryExpression {
-        parameter: Parameter;
-        block?: Block;
-        expression?: Expression;
-    }
-
-    interface CastExpression extends UnaryExpression {
-        type: Type;
-        expression: UnaryExpression;
-    }
-
-    interface ElementAccessExpression extends MemberExpression, CallExpression {
-        expression: LeftHandSideExpression;
-        argumentExpression: Expression;
-    }
-
-    interface FunctionExpression extends PrimaryExpression {
-        identifier?: SyntaxToken;
-        callSignature: CallSignature;
-        block: Block;
-    }
-
-    interface VariableDeclaration extends Node {
-        variableDeclarators: SyntaxList<VariableDeclarator>;
-    }
-
-    interface VariableDeclarator extends Node {
-        propertyName: SyntaxToken;
-        typeAnnotation?: TypeAnnotation;
-        equalsValueClause?: EqualsValueClause;
-    }
-
-    interface ArgumentList extends Node {
-        typeArgumentList?: TypeArgumentList;
-        arguments: SyntaxList<Expression>;
-    }
-
-    interface ParameterList extends Node {
-        parameters: SyntaxList<Parameter>;
-    }
-
-    interface TypeArgumentList extends Node {
-        typeArguments: SyntaxList<Type>;
-    }
-
-    interface TypeParameterList extends Node {
-        typeParameters: SyntaxList<TypeParameter>;
-    }
-
-    interface HeritageClause extends Node {
-        typeNames: SyntaxList<Name>;
-    }
-
-    interface EqualsValueClause extends Node {
-        value: Expression;
-    }
-
-    interface CaseSwitchClause extends SwitchClause {
-        expression: Expression;
-        statements: SyntaxList<Statement>;
-    }
-
-    interface DefaultSwitchClause extends SwitchClause {
-        statements: SyntaxList<Statement>;
-    }
-
-    interface ElseClause extends Node {
-        statement: Statement;
-    }
-
-    interface CatchClause extends Node {
-        identifier: SyntaxToken;
-        typeAnnotation?: TypeAnnotation;
-        block: Block;
-    }
-
-    interface FinallyClause extends Node {
-        block: Block;
-    }
-
-    interface TypeParameter extends Node {
-        identifier: SyntaxToken;
-        constraint?: Constraint;
-    }
-
-    interface Constraint extends Node {
-        type: Type;
-    }
-
-    interface SimplePropertyAssignment extends PropertyAssignment {
-        propertyName: SyntaxToken;
-        expression: Expression;
-    }
-
-    interface FunctionPropertyAssignment extends PropertyAssignment {
-        propertyName: SyntaxToken;
-        callSignature: CallSignature;
-        block: Block;
-    }
-
-    interface Parameter extends Node {
-        identifier: SyntaxToken;
-        typeAnnotation?: TypeAnnotation;
-        equalsValueClause?: EqualsValueClause;
-    }
-
-    interface EnumElement extends Node {
-        propertyName: SyntaxToken;
-        equalsValueClause?: EqualsValueClause;
-    }
-
-    interface TypeAnnotation extends Node {
-        type: Type;
-    }
-
-    interface ExternalModuleReference extends ModuleReference {
-        stringLiteral: SyntaxToken;
-    }
-
-    interface ModuleNameModuleReference extends ModuleReference {
-        moduleName: Name;
-    }
-
-    interface MemberDeclaration extends ClassElement {
-    }
-
-    interface Statement extends ModuleElement {
-    }
-
-    interface Name extends Type {
-    }
-
-    interface UnaryExpression extends Expression {
-    }
-
-    interface PostfixExpression extends UnaryExpression {
-    }
-
-    interface LeftHandSideExpression extends PostfixExpression {
-    }
-
-    interface MemberExpression extends LeftHandSideExpression {
-    }
-
-    interface CallExpression extends LeftHandSideExpression {
-    }
-
-    interface PrimaryExpression extends MemberExpression {
-    }
-
-    interface ModuleElement extends SyntaxElement {
-    }
-
-    interface ModuleReference extends Node {
-    }
-
-    interface ClassElement extends Node {
-    }
-
-    interface TypeMember extends Node {
-    }
-
-    interface PropertyAssignment extends Node {
-    }
-
-    interface SwitchClause extends Node {
-    }
-
-    interface Expression extends SyntaxElement {
-    }
-
-    interface Type extends SyntaxElement {
-    }
-}
\ No newline at end of file
diff --git a/src/services/syntax/syntaxNodes.concrete.generated.ts b/src/services/syntax/syntaxNodes.concrete.generated.ts
index 6031360a1484f..01975e12ae3f4 100644
--- a/src/services/syntax/syntaxNodes.concrete.generated.ts
+++ b/src/services/syntax/syntaxNodes.concrete.generated.ts
@@ -1,10 +1,6 @@
 ///<reference path='references.ts' />
 
-module TypeScript.Syntax.Concrete {
-    // Inject this module as the factory for producing syntax nodes in the parser.
-    Parser.syntaxFactory = Concrete;
-    export var isConcrete: boolean = true;
-
+module TypeScript {
     export class SourceUnitSyntax extends SyntaxNode {
         public syntaxTree: SyntaxTree = undefined;
         public moduleElements: IModuleElementSyntax[];
diff --git a/src/services/syntax/syntaxNodes.interfaces.generated.ts b/src/services/syntax/syntaxNodes.interfaces.generated.ts
index 37538e0c6c417..23fe6c40f56cf 100644
--- a/src/services/syntax/syntaxNodes.interfaces.generated.ts
+++ b/src/services/syntax/syntaxNodes.interfaces.generated.ts
@@ -492,98 +492,4 @@ module TypeScript {
     export interface ModuleNameModuleReferenceSyntax extends ISyntaxNode, IModuleReferenceSyntax {
         moduleName: INameSyntax;
     }
-
-    export module Syntax {
-        export interface ISyntaxFactory {
-            isConcrete: boolean;
-            SourceUnitSyntax: { new(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken): SourceUnitSyntax };
-            QualifiedNameSyntax: { new(data: number, left: INameSyntax, dotToken: ISyntaxToken, right: ISyntaxToken): QualifiedNameSyntax };
-            ObjectTypeSyntax: { new(data: number, openBraceToken: ISyntaxToken, typeMembers: ISeparatedSyntaxList<ITypeMemberSyntax>, closeBraceToken: ISyntaxToken): ObjectTypeSyntax };
-            FunctionTypeSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): FunctionTypeSyntax };
-            ArrayTypeSyntax: { new(data: number, type: ITypeSyntax, openBracketToken: ISyntaxToken, closeBracketToken: ISyntaxToken): ArrayTypeSyntax };
-            ConstructorTypeSyntax: { new(data: number, newKeyword: ISyntaxToken, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, equalsGreaterThanToken: ISyntaxToken, type: ITypeSyntax): ConstructorTypeSyntax };
-            GenericTypeSyntax: { new(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax };
-            TypeQuerySyntax: { new(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax };
-            TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ISeparatedSyntaxList<ITypeSyntax>, closeBracketToken: ISyntaxToken): TupleTypeSyntax };
-            UnionTypeSyntax: { new(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax };
-            ParenthesizedTypeSyntax: { new(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax };
-            InterfaceDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax };
-            FunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax };
-            ModuleDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax };
-            ClassDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], classKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], openBraceToken: ISyntaxToken, classElements: IClassElementSyntax[], closeBraceToken: ISyntaxToken): ClassDeclarationSyntax };
-            EnumDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], enumKeyword: ISyntaxToken, identifier: ISyntaxToken, openBraceToken: ISyntaxToken, enumElements: ISeparatedSyntaxList<EnumElementSyntax>, closeBraceToken: ISyntaxToken): EnumDeclarationSyntax };
-            ImportDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], importKeyword: ISyntaxToken, identifier: ISyntaxToken, equalsToken: ISyntaxToken, moduleReference: IModuleReferenceSyntax, semicolonToken: ISyntaxToken): ImportDeclarationSyntax };
-            ExportAssignmentSyntax: { new(data: number, exportKeyword: ISyntaxToken, equalsToken: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ExportAssignmentSyntax };
-            MemberFunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): MemberFunctionDeclarationSyntax };
-            MemberVariableDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], variableDeclarator: VariableDeclaratorSyntax, semicolonToken: ISyntaxToken): MemberVariableDeclarationSyntax };
-            ConstructorDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], constructorKeyword: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): ConstructorDeclarationSyntax };
-            IndexMemberDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], indexSignature: IndexSignatureSyntax, semicolonToken: ISyntaxToken): IndexMemberDeclarationSyntax };
-            GetAccessorSyntax: { new(data: number, modifiers: ISyntaxToken[], getKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): GetAccessorSyntax };
-            SetAccessorSyntax: { new(data: number, modifiers: ISyntaxToken[], setKeyword: ISyntaxToken, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): SetAccessorSyntax };
-            PropertySignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): PropertySignatureSyntax };
-            CallSignatureSyntax: { new(data: number, typeParameterList: TypeParameterListSyntax, parameterList: ParameterListSyntax, typeAnnotation: TypeAnnotationSyntax): CallSignatureSyntax };
-            ConstructSignatureSyntax: { new(data: number, newKeyword: ISyntaxToken, callSignature: CallSignatureSyntax): ConstructSignatureSyntax };
-            IndexSignatureSyntax: { new(data: number, openBracketToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeBracketToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax): IndexSignatureSyntax };
-            MethodSignatureSyntax: { new(data: number, propertyName: ISyntaxToken, questionToken: ISyntaxToken, callSignature: CallSignatureSyntax): MethodSignatureSyntax };
-            BlockSyntax: { new(data: number, openBraceToken: ISyntaxToken, statements: IStatementSyntax[], closeBraceToken: ISyntaxToken): BlockSyntax };
-            IfStatementSyntax: { new(data: number, ifKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax, elseClause: ElseClauseSyntax): IfStatementSyntax };
-            VariableStatementSyntax: { new(data: number, modifiers: ISyntaxToken[], variableDeclaration: VariableDeclarationSyntax, semicolonToken: ISyntaxToken): VariableStatementSyntax };
-            ExpressionStatementSyntax: { new(data: number, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ExpressionStatementSyntax };
-            ReturnStatementSyntax: { new(data: number, returnKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ReturnStatementSyntax };
-            SwitchStatementSyntax: { new(data: number, switchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, openBraceToken: ISyntaxToken, switchClauses: ISwitchClauseSyntax[], closeBraceToken: ISyntaxToken): SwitchStatementSyntax };
-            BreakStatementSyntax: { new(data: number, breakKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): BreakStatementSyntax };
-            ContinueStatementSyntax: { new(data: number, continueKeyword: ISyntaxToken, identifier: ISyntaxToken, semicolonToken: ISyntaxToken): ContinueStatementSyntax };
-            ForStatementSyntax: { new(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax, firstSemicolonToken: ISyntaxToken, condition: IExpressionSyntax, secondSemicolonToken: ISyntaxToken, incrementor: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): ForStatementSyntax };
-            ForInStatementSyntax: { new(data: number, forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, left: IExpressionSyntax, inKeyword: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): ForInStatementSyntax };
-            EmptyStatementSyntax: { new(data: number, semicolonToken: ISyntaxToken): EmptyStatementSyntax };
-            ThrowStatementSyntax: { new(data: number, throwKeyword: ISyntaxToken, expression: IExpressionSyntax, semicolonToken: ISyntaxToken): ThrowStatementSyntax };
-            WhileStatementSyntax: { new(data: number, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): WhileStatementSyntax };
-            TryStatementSyntax: { new(data: number, tryKeyword: ISyntaxToken, block: BlockSyntax, catchClause: CatchClauseSyntax, finallyClause: FinallyClauseSyntax): TryStatementSyntax };
-            LabeledStatementSyntax: { new(data: number, identifier: ISyntaxToken, colonToken: ISyntaxToken, statement: IStatementSyntax): LabeledStatementSyntax };
-            DoStatementSyntax: { new(data: number, doKeyword: ISyntaxToken, statement: IStatementSyntax, whileKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, semicolonToken: ISyntaxToken): DoStatementSyntax };
-            DebuggerStatementSyntax: { new(data: number, debuggerKeyword: ISyntaxToken, semicolonToken: ISyntaxToken): DebuggerStatementSyntax };
-            WithStatementSyntax: { new(data: number, withKeyword: ISyntaxToken, openParenToken: ISyntaxToken, condition: IExpressionSyntax, closeParenToken: ISyntaxToken, statement: IStatementSyntax): WithStatementSyntax };
-            PrefixUnaryExpressionSyntax: { new(data: number, operatorToken: ISyntaxToken, operand: IUnaryExpressionSyntax): PrefixUnaryExpressionSyntax };
-            DeleteExpressionSyntax: { new(data: number, deleteKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): DeleteExpressionSyntax };
-            TypeOfExpressionSyntax: { new(data: number, typeOfKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): TypeOfExpressionSyntax };
-            VoidExpressionSyntax: { new(data: number, voidKeyword: ISyntaxToken, expression: IUnaryExpressionSyntax): VoidExpressionSyntax };
-            ConditionalExpressionSyntax: { new(data: number, condition: IExpressionSyntax, questionToken: ISyntaxToken, whenTrue: IExpressionSyntax, colonToken: ISyntaxToken, whenFalse: IExpressionSyntax): ConditionalExpressionSyntax };
-            BinaryExpressionSyntax: { new(data: number, left: IExpressionSyntax, operatorToken: ISyntaxToken, right: IExpressionSyntax): BinaryExpressionSyntax };
-            PostfixUnaryExpressionSyntax: { new(data: number, operand: ILeftHandSideExpressionSyntax, operatorToken: ISyntaxToken): PostfixUnaryExpressionSyntax };
-            MemberAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, dotToken: ISyntaxToken, name: ISyntaxToken): MemberAccessExpressionSyntax };
-            InvocationExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, argumentList: ArgumentListSyntax): InvocationExpressionSyntax };
-            ArrayLiteralExpressionSyntax: { new(data: number, openBracketToken: ISyntaxToken, expressions: ISeparatedSyntaxList<IExpressionSyntax>, closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax };
-            ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList<IPropertyAssignmentSyntax>, closeBraceToken: ISyntaxToken): ObjectLiteralExpressionSyntax };
-            ObjectCreationExpressionSyntax: { new(data: number, newKeyword: ISyntaxToken, expression: IMemberExpressionSyntax, argumentList: ArgumentListSyntax): ObjectCreationExpressionSyntax };
-            ParenthesizedExpressionSyntax: { new(data: number, openParenToken: ISyntaxToken, expression: IExpressionSyntax, closeParenToken: ISyntaxToken): ParenthesizedExpressionSyntax };
-            ParenthesizedArrowFunctionExpressionSyntax: { new(data: number, callSignature: CallSignatureSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): ParenthesizedArrowFunctionExpressionSyntax };
-            SimpleArrowFunctionExpressionSyntax: { new(data: number, parameter: ParameterSyntax, equalsGreaterThanToken: ISyntaxToken, block: BlockSyntax, expression: IExpressionSyntax): SimpleArrowFunctionExpressionSyntax };
-            CastExpressionSyntax: { new(data: number, lessThanToken: ISyntaxToken, type: ITypeSyntax, greaterThanToken: ISyntaxToken, expression: IUnaryExpressionSyntax): CastExpressionSyntax };
-            ElementAccessExpressionSyntax: { new(data: number, expression: ILeftHandSideExpressionSyntax, openBracketToken: ISyntaxToken, argumentExpression: IExpressionSyntax, closeBracketToken: ISyntaxToken): ElementAccessExpressionSyntax };
-            FunctionExpressionSyntax: { new(data: number, functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionExpressionSyntax };
-            OmittedExpressionSyntax: { new(data: number): OmittedExpressionSyntax };
-            VariableDeclarationSyntax: { new(data: number, varKeyword: ISyntaxToken, variableDeclarators: ISeparatedSyntaxList<VariableDeclaratorSyntax>): VariableDeclarationSyntax };
-            VariableDeclaratorSyntax: { new(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): VariableDeclaratorSyntax };
-            ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: ISeparatedSyntaxList<IExpressionSyntax>, closeParenToken: ISyntaxToken): ArgumentListSyntax };
-            ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList<ParameterSyntax>, closeParenToken: ISyntaxToken): ParameterListSyntax };
-            TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList<ITypeSyntax>, greaterThanToken: ISyntaxToken): TypeArgumentListSyntax };
-            TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList<TypeParameterSyntax>, greaterThanToken: ISyntaxToken): TypeParameterListSyntax };
-            HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList<INameSyntax>): HeritageClauseSyntax };
-            EqualsValueClauseSyntax: { new(data: number, equalsToken: ISyntaxToken, value: IExpressionSyntax): EqualsValueClauseSyntax };
-            CaseSwitchClauseSyntax: { new(data: number, caseKeyword: ISyntaxToken, expression: IExpressionSyntax, colonToken: ISyntaxToken, statements: IStatementSyntax[]): CaseSwitchClauseSyntax };
-            DefaultSwitchClauseSyntax: { new(data: number, defaultKeyword: ISyntaxToken, colonToken: ISyntaxToken, statements: IStatementSyntax[]): DefaultSwitchClauseSyntax };
-            ElseClauseSyntax: { new(data: number, elseKeyword: ISyntaxToken, statement: IStatementSyntax): ElseClauseSyntax };
-            CatchClauseSyntax: { new(data: number, catchKeyword: ISyntaxToken, openParenToken: ISyntaxToken, identifier: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, closeParenToken: ISyntaxToken, block: BlockSyntax): CatchClauseSyntax };
-            FinallyClauseSyntax: { new(data: number, finallyKeyword: ISyntaxToken, block: BlockSyntax): FinallyClauseSyntax };
-            TypeParameterSyntax: { new(data: number, identifier: ISyntaxToken, constraint: ConstraintSyntax): TypeParameterSyntax };
-            ConstraintSyntax: { new(data: number, extendsKeyword: ISyntaxToken, typeOrExpression: ISyntaxNodeOrToken): ConstraintSyntax };
-            SimplePropertyAssignmentSyntax: { new(data: number, propertyName: ISyntaxToken, colonToken: ISyntaxToken, expression: IExpressionSyntax): SimplePropertyAssignmentSyntax };
-            FunctionPropertyAssignmentSyntax: { new(data: number, propertyName: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax): FunctionPropertyAssignmentSyntax };
-            ParameterSyntax: { new(data: number, dotDotDotToken: ISyntaxToken, modifiers: ISyntaxToken[], identifier: ISyntaxToken, questionToken: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): ParameterSyntax };
-            EnumElementSyntax: { new(data: number, propertyName: ISyntaxToken, equalsValueClause: EqualsValueClauseSyntax): EnumElementSyntax };
-            TypeAnnotationSyntax: { new(data: number, colonToken: ISyntaxToken, type: ITypeSyntax): TypeAnnotationSyntax };
-            ExternalModuleReferenceSyntax: { new(data: number, requireKeyword: ISyntaxToken, openParenToken: ISyntaxToken, stringLiteral: ISyntaxToken, closeParenToken: ISyntaxToken): ExternalModuleReferenceSyntax };
-            ModuleNameModuleReferenceSyntax: { new(data: number, moduleName: INameSyntax): ModuleNameModuleReferenceSyntax };
-        }
-    }
 }
\ No newline at end of file
diff --git a/src/services/syntax/syntaxTree.ts b/src/services/syntax/syntaxTree.ts
index a568e2313be4d..6f0b547b4a164 100644
--- a/src/services/syntax/syntaxTree.ts
+++ b/src/services/syntax/syntaxTree.ts
@@ -4,7 +4,6 @@ module TypeScript {
     export var syntaxDiagnosticsTime: number = 0;
 
     export class SyntaxTree {
-        private _isConcrete: boolean;
         private _sourceUnit: SourceUnitSyntax;
         private _isDeclaration: boolean;
         private _parserDiagnostics: Diagnostic[];
@@ -17,14 +16,12 @@ module TypeScript {
         private _amdDependencies: string[];
         private _isExternalModule: boolean;
 
-        constructor(isConcrete: boolean,
-                    sourceUnit: SourceUnitSyntax,
+        constructor(sourceUnit: SourceUnitSyntax,
                     isDeclaration: boolean,
                     diagnostics: Diagnostic[],
                     fileName: string,
                     public text: ISimpleText,
                     languageVersion: ts.ScriptTarget) {
-            this._isConcrete = isConcrete;
             this._sourceUnit = sourceUnit;
             this._isDeclaration = isDeclaration;
             this._parserDiagnostics = diagnostics;
@@ -35,10 +32,6 @@ module TypeScript {
             sourceUnit.syntaxTree = this;
         }
 
-        public isConcrete(): boolean {
-            return this._isConcrete;
-        }
-
         public sourceUnit(): SourceUnitSyntax {
             return this._sourceUnit;
         }