mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-06 11:54:44 -06:00
Merge pull request #1028 from Microsoft/abstractTrees
Remove abstract syntax tree generation support from fidelity.
This commit is contained in:
CyrusNajmabadi
commit
bcf319fd40
@ -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) {
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
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;
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
// 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(
|
||||
|
||||
@ -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' />
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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 {
|
||||
}
|
||||
}
|
||||
@ -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[];
|
||||
|
||||
@ -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 };
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user