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