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 = "///\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 @@
///
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 = 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(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(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(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(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(), 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(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(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(), 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(
@@ -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 @@
///
///
///
-///
// SyntaxDedenter depends on SyntaxRewriter
// ///
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 = "///\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 += "(" + 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 @@
-///
-
-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 extends SyntaxElement {
- length: number;
- item(index: number): T;
- }
-
- interface SourceUnit extends Node {
- moduleElements: SyntaxList;
- }
-
- interface QualifiedName extends Name {
- left: Name;
- right: SyntaxToken;
- }
-
- interface ObjectType extends Type {
- typeMembers: SyntaxList;
- }
-
- 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;
- body: ObjectType;
- }
-
- interface FunctionDeclaration extends Statement {
- identifier: SyntaxToken;
- callSignature: CallSignature;
- block?: Block;
- }
-
- interface ModuleDeclaration extends ModuleElement {
- name?: Name;
- stringLiteral?: SyntaxToken;
- moduleElements: SyntaxList;
- }
-
- interface ClassDeclaration extends ModuleElement {
- identifier: SyntaxToken;
- typeParameterList?: TypeParameterList;
- heritageClauses: SyntaxList;
- classElements: SyntaxList;
- }
-
- interface EnumDeclaration extends ModuleElement {
- identifier: SyntaxToken;
- enumElements: SyntaxList;
- }
-
- 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;
- typeAnnotation?: TypeAnnotation;
- }
-
- interface MethodSignature extends TypeMember {
- propertyName: SyntaxToken;
- callSignature: CallSignature;
- }
-
- interface Block extends Statement {
- statements: SyntaxList;
- }
-
- 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;
- }
-
- 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;
- }
-
- interface ObjectLiteralExpression extends PrimaryExpression {
- propertyAssignments: SyntaxList;
- }
-
- 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;
- }
-
- interface VariableDeclarator extends Node {
- propertyName: SyntaxToken;
- typeAnnotation?: TypeAnnotation;
- equalsValueClause?: EqualsValueClause;
- }
-
- interface ArgumentList extends Node {
- typeArgumentList?: TypeArgumentList;
- arguments: SyntaxList;
- }
-
- interface ParameterList extends Node {
- parameters: SyntaxList;
- }
-
- interface TypeArgumentList extends Node {
- typeArguments: SyntaxList;
- }
-
- interface TypeParameterList extends Node {
- typeParameters: SyntaxList;
- }
-
- interface HeritageClause extends Node {
- typeNames: SyntaxList;
- }
-
- interface EqualsValueClause extends Node {
- value: Expression;
- }
-
- interface CaseSwitchClause extends SwitchClause {
- expression: Expression;
- statements: SyntaxList;
- }
-
- interface DefaultSwitchClause extends SwitchClause {
- statements: SyntaxList;
- }
-
- 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 @@
///
-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, 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, 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, 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, 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, closeBracketToken: ISyntaxToken): ArrayLiteralExpressionSyntax };
- ObjectLiteralExpressionSyntax: { new(data: number, openBraceToken: ISyntaxToken, propertyAssignments: ISeparatedSyntaxList, 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): VariableDeclarationSyntax };
- VariableDeclaratorSyntax: { new(data: number, propertyName: ISyntaxToken, typeAnnotation: TypeAnnotationSyntax, equalsValueClause: EqualsValueClauseSyntax): VariableDeclaratorSyntax };
- ArgumentListSyntax: { new(data: number, typeArgumentList: TypeArgumentListSyntax, openParenToken: ISyntaxToken, arguments: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ArgumentListSyntax };
- ParameterListSyntax: { new(data: number, openParenToken: ISyntaxToken, parameters: ISeparatedSyntaxList, closeParenToken: ISyntaxToken): ParameterListSyntax };
- TypeArgumentListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeArguments: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeArgumentListSyntax };
- TypeParameterListSyntax: { new(data: number, lessThanToken: ISyntaxToken, typeParameters: ISeparatedSyntaxList, greaterThanToken: ISyntaxToken): TypeParameterListSyntax };
- HeritageClauseSyntax: { new(data: number, extendsOrImplementsKeyword: ISyntaxToken, typeNames: ISeparatedSyntaxList): 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;
}