/// <reference path="utilities.ts"/>

/// <reference path="scanner.ts"/>

namespace ts {

let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let TokenConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let IdentifierConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

export function createNode(kind: SyntaxKind, pos?: number, end?: number): Node {

if (kind === SyntaxKind.SourceFile) {

return new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, pos, end);

}

else if (kind === SyntaxKind.Identifier) {

return new (IdentifierConstructor || (IdentifierConstructor = objectAllocator.getIdentifierConstructor()))(kind, pos, end);

}

else if (kind < SyntaxKind.FirstNode) {

return new (TokenConstructor || (TokenConstructor = objectAllocator.getTokenConstructor()))(kind, pos, end);

}

else {

return new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, pos, end);

}

}

function visitNode<T>(cbNode: (node: Node) => T, node: Node): T {

if (node) {

return cbNode(node);

}

}

function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]) {

if (nodes) {

return cbNodes(nodes);

}

}

function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]) {

if (nodes) {

for (const node of nodes) {

const result = cbNode(node);

if (result) {

return result;

}

}

}

}

// Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes

// stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,

// embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns

// a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.

export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T {

if (!node) {

return;

}

// The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray

// callback parameters, but that causes a closure allocation for each invocation with noticeable effects

// on performance.

const visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;

const cbNodes = cbNodeArray || cbNode;

switch (node.kind) {

case SyntaxKind.QualifiedName:

return visitNode(cbNode, (<QualifiedName>node).left) ||

visitNode(cbNode, (<QualifiedName>node).right);

case SyntaxKind.TypeParameter:

return visitNode(cbNode, (<TypeParameterDeclaration>node).name) ||

visitNode(cbNode, (<TypeParameterDeclaration>node).constraint) ||

visitNode(cbNode, (<TypeParameterDeclaration>node).expression);

case SyntaxKind.ShorthandPropertyAssignment:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).name) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);

case SyntaxKind.Parameter:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

case SyntaxKind.PropertyAssignment:

case SyntaxKind.VariableDeclaration:

case SyntaxKind.BindingElement:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).propertyName) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).dotDotDotToken) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).name) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).questionToken) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).type) ||

visitNode(cbNode, (<VariableLikeDeclaration>node).initializer);

case SyntaxKind.FunctionType:

case SyntaxKind.ConstructorType:

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.IndexSignature:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNodes(cbNodes, (<SignatureDeclaration>node).typeParameters) ||

visitNodes(cbNodes, (<SignatureDeclaration>node).parameters) ||

visitNode(cbNode, (<SignatureDeclaration>node).type);

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionExpression:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ArrowFunction:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<FunctionLikeDeclaration>node).asteriskToken) ||

visitNode(cbNode, (<FunctionLikeDeclaration>node).name) ||

visitNode(cbNode, (<FunctionLikeDeclaration>node).questionToken) ||

visitNodes(cbNodes, (<FunctionLikeDeclaration>node).typeParameters) ||

visitNodes(cbNodes, (<FunctionLikeDeclaration>node).parameters) ||

visitNode(cbNode, (<FunctionLikeDeclaration>node).type) ||

visitNode(cbNode, (<ArrowFunction>node).equalsGreaterThanToken) ||

visitNode(cbNode, (<FunctionLikeDeclaration>node).body);

case SyntaxKind.TypeReference:

return visitNode(cbNode, (<TypeReferenceNode>node).typeName) ||

visitNodes(cbNodes, (<TypeReferenceNode>node).typeArguments);

case SyntaxKind.TypePredicate:

return visitNode(cbNode, (<TypePredicateNode>node).parameterName) ||

visitNode(cbNode, (<TypePredicateNode>node).type);

case SyntaxKind.TypeQuery:

return visitNode(cbNode, (<TypeQueryNode>node).exprName);

case SyntaxKind.TypeLiteral:

return visitNodes(cbNodes, (<TypeLiteralNode>node).members);

case SyntaxKind.ArrayType:

return visitNode(cbNode, (<ArrayTypeNode>node).elementType);

case SyntaxKind.TupleType:

return visitNodes(cbNodes, (<TupleTypeNode>node).elementTypes);

case SyntaxKind.UnionType:

case SyntaxKind.IntersectionType:

return visitNodes(cbNodes, (<UnionOrIntersectionTypeNode>node).types);

case SyntaxKind.ParenthesizedType:

return visitNode(cbNode, (<ParenthesizedTypeNode>node).type);

case SyntaxKind.LiteralType:

return visitNode(cbNode, (<LiteralTypeNode>node).literal);

case SyntaxKind.ObjectBindingPattern:

case SyntaxKind.ArrayBindingPattern:

return visitNodes(cbNodes, (<BindingPattern>node).elements);

case SyntaxKind.ArrayLiteralExpression:

return visitNodes(cbNodes, (<ArrayLiteralExpression>node).elements);

case SyntaxKind.ObjectLiteralExpression:

return visitNodes(cbNodes, (<ObjectLiteralExpression>node).properties);

case SyntaxKind.PropertyAccessExpression:

return visitNode(cbNode, (<PropertyAccessExpression>node).expression) ||

visitNode(cbNode, (<PropertyAccessExpression>node).name);

case SyntaxKind.ElementAccessExpression:

return visitNode(cbNode, (<ElementAccessExpression>node).expression) ||

visitNode(cbNode, (<ElementAccessExpression>node).argumentExpression);

case SyntaxKind.CallExpression:

case SyntaxKind.NewExpression:

return visitNode(cbNode, (<CallExpression>node).expression) ||

visitNodes(cbNodes, (<CallExpression>node).typeArguments) ||

visitNodes(cbNodes, (<CallExpression>node).arguments);

case SyntaxKind.TaggedTemplateExpression:

return visitNode(cbNode, (<TaggedTemplateExpression>node).tag) ||

visitNode(cbNode, (<TaggedTemplateExpression>node).template);

case SyntaxKind.TypeAssertionExpression:

return visitNode(cbNode, (<TypeAssertion>node).type) ||

visitNode(cbNode, (<TypeAssertion>node).expression);

case SyntaxKind.ParenthesizedExpression:

return visitNode(cbNode, (<ParenthesizedExpression>node).expression);

case SyntaxKind.DeleteExpression:

return visitNode(cbNode, (<DeleteExpression>node).expression);

case SyntaxKind.TypeOfExpression:

return visitNode(cbNode, (<TypeOfExpression>node).expression);

case SyntaxKind.VoidExpression:

return visitNode(cbNode, (<VoidExpression>node).expression);

case SyntaxKind.PrefixUnaryExpression:

return visitNode(cbNode, (<PrefixUnaryExpression>node).operand);

case SyntaxKind.YieldExpression:

return visitNode(cbNode, (<YieldExpression>node).asteriskToken) ||

visitNode(cbNode, (<YieldExpression>node).expression);

case SyntaxKind.AwaitExpression:

return visitNode(cbNode, (<AwaitExpression>node).expression);

case SyntaxKind.PostfixUnaryExpression:

return visitNode(cbNode, (<PostfixUnaryExpression>node).operand);

case SyntaxKind.BinaryExpression:

return visitNode(cbNode, (<BinaryExpression>node).left) ||

visitNode(cbNode, (<BinaryExpression>node).operatorToken) ||

visitNode(cbNode, (<BinaryExpression>node).right);

case SyntaxKind.AsExpression:

return visitNode(cbNode, (<AsExpression>node).expression) ||

visitNode(cbNode, (<AsExpression>node).type);

case SyntaxKind.NonNullExpression:

return visitNode(cbNode, (<NonNullExpression>node).expression);

case SyntaxKind.ConditionalExpression:

return visitNode(cbNode, (<ConditionalExpression>node).condition) ||

visitNode(cbNode, (<ConditionalExpression>node).questionToken) ||

visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||

visitNode(cbNode, (<ConditionalExpression>node).colonToken) ||

visitNode(cbNode, (<ConditionalExpression>node).whenFalse);

case SyntaxKind.SpreadElementExpression:

return visitNode(cbNode, (<SpreadElementExpression>node).expression);

case SyntaxKind.Block:

case SyntaxKind.ModuleBlock:

return visitNodes(cbNodes, (<Block>node).statements);

case SyntaxKind.SourceFile:

return visitNodes(cbNodes, (<SourceFile>node).statements) ||

visitNode(cbNode, (<SourceFile>node).endOfFileToken);

case SyntaxKind.VariableStatement:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<VariableStatement>node).declarationList);

case SyntaxKind.VariableDeclarationList:

return visitNodes(cbNodes, (<VariableDeclarationList>node).declarations);

case SyntaxKind.ExpressionStatement:

return visitNode(cbNode, (<ExpressionStatement>node).expression);

case SyntaxKind.IfStatement:

return visitNode(cbNode, (<IfStatement>node).expression) ||

visitNode(cbNode, (<IfStatement>node).thenStatement) ||

visitNode(cbNode, (<IfStatement>node).elseStatement);

case SyntaxKind.DoStatement:

return visitNode(cbNode, (<DoStatement>node).statement) ||

visitNode(cbNode, (<DoStatement>node).expression);

case SyntaxKind.WhileStatement:

return visitNode(cbNode, (<WhileStatement>node).expression) ||

visitNode(cbNode, (<WhileStatement>node).statement);

case SyntaxKind.ForStatement:

return visitNode(cbNode, (<ForStatement>node).initializer) ||

visitNode(cbNode, (<ForStatement>node).condition) ||

visitNode(cbNode, (<ForStatement>node).incrementor) ||

visitNode(cbNode, (<ForStatement>node).statement);

case SyntaxKind.ForInStatement:

return visitNode(cbNode, (<ForInStatement>node).initializer) ||

visitNode(cbNode, (<ForInStatement>node).expression) ||

visitNode(cbNode, (<ForInStatement>node).statement);

case SyntaxKind.ForOfStatement:

return visitNode(cbNode, (<ForOfStatement>node).initializer) ||

visitNode(cbNode, (<ForOfStatement>node).expression) ||

visitNode(cbNode, (<ForOfStatement>node).statement);

case SyntaxKind.ContinueStatement:

case SyntaxKind.BreakStatement:

return visitNode(cbNode, (<BreakOrContinueStatement>node).label);

case SyntaxKind.ReturnStatement:

return visitNode(cbNode, (<ReturnStatement>node).expression);

case SyntaxKind.WithStatement:

return visitNode(cbNode, (<WithStatement>node).expression) ||

visitNode(cbNode, (<WithStatement>node).statement);

case SyntaxKind.SwitchStatement:

return visitNode(cbNode, (<SwitchStatement>node).expression) ||

visitNode(cbNode, (<SwitchStatement>node).caseBlock);

case SyntaxKind.CaseBlock:

return visitNodes(cbNodes, (<CaseBlock>node).clauses);

case SyntaxKind.CaseClause:

return visitNode(cbNode, (<CaseClause>node).expression) ||

visitNodes(cbNodes, (<CaseClause>node).statements);

case SyntaxKind.DefaultClause:

return visitNodes(cbNodes, (<DefaultClause>node).statements);

case SyntaxKind.LabeledStatement:

return visitNode(cbNode, (<LabeledStatement>node).label) ||

visitNode(cbNode, (<LabeledStatement>node).statement);

case SyntaxKind.ThrowStatement:

return visitNode(cbNode, (<ThrowStatement>node).expression);

case SyntaxKind.TryStatement:

return visitNode(cbNode, (<TryStatement>node).tryBlock) ||

visitNode(cbNode, (<TryStatement>node).catchClause) ||

visitNode(cbNode, (<TryStatement>node).finallyBlock);

case SyntaxKind.CatchClause:

return visitNode(cbNode, (<CatchClause>node).variableDeclaration) ||

visitNode(cbNode, (<CatchClause>node).block);

case SyntaxKind.Decorator:

return visitNode(cbNode, (<Decorator>node).expression);

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ClassLikeDeclaration>node).name) ||

visitNodes(cbNodes, (<ClassLikeDeclaration>node).typeParameters) ||

visitNodes(cbNodes, (<ClassLikeDeclaration>node).heritageClauses) ||

visitNodes(cbNodes, (<ClassLikeDeclaration>node).members);

case SyntaxKind.InterfaceDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<InterfaceDeclaration>node).name) ||

visitNodes(cbNodes, (<InterfaceDeclaration>node).typeParameters) ||

visitNodes(cbNodes, (<ClassDeclaration>node).heritageClauses) ||

visitNodes(cbNodes, (<InterfaceDeclaration>node).members);

case SyntaxKind.TypeAliasDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<TypeAliasDeclaration>node).name) ||

visitNodes(cbNodes, (<TypeAliasDeclaration>node).typeParameters) ||

visitNode(cbNode, (<TypeAliasDeclaration>node).type);

case SyntaxKind.EnumDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<EnumDeclaration>node).name) ||

visitNodes(cbNodes, (<EnumDeclaration>node).members);

case SyntaxKind.EnumMember:

return visitNode(cbNode, (<EnumMember>node).name) ||

visitNode(cbNode, (<EnumMember>node).initializer);

case SyntaxKind.ModuleDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ModuleDeclaration>node).name) ||

visitNode(cbNode, (<ModuleDeclaration>node).body);

case SyntaxKind.ImportEqualsDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ImportEqualsDeclaration>node).name) ||

visitNode(cbNode, (<ImportEqualsDeclaration>node).moduleReference);

case SyntaxKind.ImportDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ImportDeclaration>node).importClause) ||

visitNode(cbNode, (<ImportDeclaration>node).moduleSpecifier);

case SyntaxKind.ImportClause:

return visitNode(cbNode, (<ImportClause>node).name) ||

visitNode(cbNode, (<ImportClause>node).namedBindings);

case SyntaxKind.NamespaceExportDeclaration:

return visitNode(cbNode, (<NamespaceExportDeclaration>node).name);

case SyntaxKind.NamespaceImport:

return visitNode(cbNode, (<NamespaceImport>node).name);

case SyntaxKind.NamedImports:

case SyntaxKind.NamedExports:

return visitNodes(cbNodes, (<NamedImportsOrExports>node).elements);

case SyntaxKind.ExportDeclaration:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ExportDeclaration>node).exportClause) ||

visitNode(cbNode, (<ExportDeclaration>node).moduleSpecifier);

case SyntaxKind.ImportSpecifier:

case SyntaxKind.ExportSpecifier:

return visitNode(cbNode, (<ImportOrExportSpecifier>node).propertyName) ||

visitNode(cbNode, (<ImportOrExportSpecifier>node).name);

case SyntaxKind.ExportAssignment:

return visitNodes(cbNodes, node.decorators) ||

visitNodes(cbNodes, node.modifiers) ||

visitNode(cbNode, (<ExportAssignment>node).expression);

case SyntaxKind.TemplateExpression:

return visitNode(cbNode, (<TemplateExpression>node).head) || visitNodes(cbNodes, (<TemplateExpression>node).templateSpans);

case SyntaxKind.TemplateSpan:

return visitNode(cbNode, (<TemplateSpan>node).expression) || visitNode(cbNode, (<TemplateSpan>node).literal);

case SyntaxKind.ComputedPropertyName:

return visitNode(cbNode, (<ComputedPropertyName>node).expression);

case SyntaxKind.HeritageClause:

return visitNodes(cbNodes, (<HeritageClause>node).types);

case SyntaxKind.ExpressionWithTypeArguments:

return visitNode(cbNode, (<ExpressionWithTypeArguments>node).expression) ||

visitNodes(cbNodes, (<ExpressionWithTypeArguments>node).typeArguments);

case SyntaxKind.ExternalModuleReference:

return visitNode(cbNode, (<ExternalModuleReference>node).expression);

case SyntaxKind.MissingDeclaration:

return visitNodes(cbNodes, node.decorators);

case SyntaxKind.JsxElement:

return visitNode(cbNode, (<JsxElement>node).openingElement) ||

visitNodes(cbNodes, (<JsxElement>node).children) ||

visitNode(cbNode, (<JsxElement>node).closingElement);

case SyntaxKind.JsxSelfClosingElement:

case SyntaxKind.JsxOpeningElement:

return visitNode(cbNode, (<JsxOpeningLikeElement>node).tagName) ||

visitNodes(cbNodes, (<JsxOpeningLikeElement>node).attributes);

case SyntaxKind.JsxAttribute:

return visitNode(cbNode, (<JsxAttribute>node).name) ||

visitNode(cbNode, (<JsxAttribute>node).initializer);

case SyntaxKind.JsxSpreadAttribute:

return visitNode(cbNode, (<JsxSpreadAttribute>node).expression);

case SyntaxKind.JsxExpression:

return visitNode(cbNode, (<JsxExpression>node).expression);

case SyntaxKind.JsxClosingElement:

return visitNode(cbNode, (<JsxClosingElement>node).tagName);

case SyntaxKind.JSDocTypeExpression:

return visitNode(cbNode, (<JSDocTypeExpression>node).type);

case SyntaxKind.JSDocUnionType:

return visitNodes(cbNodes, (<JSDocUnionType>node).types);

case SyntaxKind.JSDocTupleType:

return visitNodes(cbNodes, (<JSDocTupleType>node).types);

case SyntaxKind.JSDocArrayType:

return visitNode(cbNode, (<JSDocArrayType>node).elementType);

case SyntaxKind.JSDocNonNullableType:

return visitNode(cbNode, (<JSDocNonNullableType>node).type);

case SyntaxKind.JSDocNullableType:

return visitNode(cbNode, (<JSDocNullableType>node).type);

case SyntaxKind.JSDocRecordType:

return visitNodes(cbNodes, (<JSDocRecordType>node).members);

case SyntaxKind.JSDocTypeReference:

return visitNode(cbNode, (<JSDocTypeReference>node).name) ||

visitNodes(cbNodes, (<JSDocTypeReference>node).typeArguments);

case SyntaxKind.JSDocOptionalType:

return visitNode(cbNode, (<JSDocOptionalType>node).type);

case SyntaxKind.JSDocFunctionType:

return visitNodes(cbNodes, (<JSDocFunctionType>node).parameters) ||

visitNode(cbNode, (<JSDocFunctionType>node).type);

case SyntaxKind.JSDocVariadicType:

return visitNode(cbNode, (<JSDocVariadicType>node).type);

case SyntaxKind.JSDocConstructorType:

return visitNode(cbNode, (<JSDocConstructorType>node).type);

case SyntaxKind.JSDocThisType:

return visitNode(cbNode, (<JSDocThisType>node).type);

case SyntaxKind.JSDocRecordMember:

return visitNode(cbNode, (<JSDocRecordMember>node).name) ||

visitNode(cbNode, (<JSDocRecordMember>node).type);

case SyntaxKind.JSDocComment:

return visitNodes(cbNodes, (<JSDocComment>node).tags);

case SyntaxKind.JSDocParameterTag:

return visitNode(cbNode, (<JSDocParameterTag>node).preParameterName) ||

visitNode(cbNode, (<JSDocParameterTag>node).typeExpression) ||

visitNode(cbNode, (<JSDocParameterTag>node).postParameterName);

case SyntaxKind.JSDocReturnTag:

return visitNode(cbNode, (<JSDocReturnTag>node).typeExpression);

case SyntaxKind.JSDocTypeTag:

return visitNode(cbNode, (<JSDocTypeTag>node).typeExpression);

case SyntaxKind.JSDocTemplateTag:

return visitNodes(cbNodes, (<JSDocTemplateTag>node).typeParameters);

case SyntaxKind.JSDocTypedefTag:

return visitNode(cbNode, (<JSDocTypedefTag>node).typeExpression) ||

visitNode(cbNode, (<JSDocTypedefTag>node).name) ||

visitNode(cbNode, (<JSDocTypedefTag>node).jsDocTypeLiteral);

case SyntaxKind.JSDocTypeLiteral:

return visitNodes(cbNodes, (<JSDocTypeLiteral>node).jsDocPropertyTags);

case SyntaxKind.JSDocPropertyTag:

return visitNode(cbNode, (<JSDocPropertyTag>node).typeExpression) ||

visitNode(cbNode, (<JSDocPropertyTag>node).name);

}

}

export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {

const start = performance.mark();

const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);

performance.measure("Parse", start);

return result;

}

export function isExternalModule(file: SourceFile): boolean {

return file.externalModuleIndicator !== undefined;

}

// Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter

// indicates what changed between the 'text' that this SourceFile has and the 'newText'.

// The SourceFile will be created with the compiler attempting to reuse as many nodes from

// this file as possible.

//

// Note: this function mutates nodes from this SourceFile. That means any existing nodes

// from this SourceFile that are being held onto may change as a result (including

// becoming detached from any SourceFile). It is recommended that this SourceFile not

// be used once 'update' is called on it.

export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile {

return IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);

}

/* @internal */

export function parseIsolatedJSDocComment(content: string, start?: number, length?: number) {

const result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length);

if (result && result.jsDocComment) {

// because the jsDocComment was parsed out of the source file, it might

// not be covered by the fixupParentReferences.

Parser.fixupParentReferences(result.jsDocComment);

}

return result;

}

/* @internal */

// Exposed only for testing.

export function parseJSDocTypeExpressionForTests(content: string, start?: number, length?: number) {

return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length);

}

// Implement the parser as a singleton module. We do this for perf reasons because creating

// parser instances can actually be expensive enough to impact us on projects with many source

// files.

namespace Parser {

// Share a single scanner across all calls to parse a source file. This helps speed things

// up by avoiding the cost of creating/compiling scanners over and over again.

const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);

const disallowInAndDecoratorContext = NodeFlags.DisallowInContext | NodeFlags.DecoratorContext;

// capture constructors in 'initializeState' to avoid null checks

let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let TokenConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let IdentifierConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let sourceFile: SourceFile;

let parseDiagnostics: Diagnostic[];

let syntaxCursor: IncrementalParser.SyntaxCursor;

let currentToken: SyntaxKind;

let sourceText: string;

let nodeCount: number;

let identifiers: Map<string>;

let identifierCount: number;

let parsingContext: ParsingContext;

// Flags that dictate what parsing context we're in. For example:

// Whether or not we are in strict parsing mode. All that changes in strict parsing mode is

// that some tokens that would be considered identifiers may be considered keywords.

//

// When adding more parser context flags, consider which is the more common case that the

// flag will be in. This should be the 'false' state for that flag. The reason for this is

// that we don't store data in our nodes unless the value is in the *non-default* state. So,

// for example, more often than code 'allows-in' (or doesn't 'disallow-in'). We opt for

// 'disallow-in' set to 'false'. Otherwise, if we had 'allowsIn' set to 'true', then almost

// all nodes would need extra state on them to store this info.

//

// Note: 'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6

// grammar specification.

//

// An important thing about these context concepts. By default they are effectively inherited

// while parsing through every grammar production. i.e. if you don't change them, then when

// you parse a sub-production, it will have the same context values as the parent production.

// This is great most of the time. After all, consider all the 'expression' grammar productions

// and how nearly all of them pass along the 'in' and 'yield' context values:

//

// EqualityExpression[In, Yield] :

// RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield]

//

// Where you have to be careful is then understanding what the points are in the grammar

// where the values are *not* passed along. For example:

//

// SingleNameBinding[Yield,GeneratorParameter]

// [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt

// [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt

//

// Here this is saying that if the GeneratorParameter context flag is set, that we should

// explicitly set the 'yield' context flag to false before calling into the BindingIdentifier

// and we should explicitly unset the 'yield' context flag before calling into the Initializer.

// production. Conversely, if the GeneratorParameter context flag is not set, then we

// should leave the 'yield' context flag alone.

//

// Getting this all correct is tricky and requires careful reading of the grammar to

// understand when these values should be changed versus when they should be inherited.

//

// Note: it should not be necessary to save/restore these flags during speculative/lookahead

// parsing. These context flags are naturally stored and restored through normal recursive

// descent parsing and unwinding.

let contextFlags: NodeFlags;

// Whether or not we've had a parse error since creating the last AST node. If we have

// encountered an error, it will be stored on the next AST node we create. Parse errors

// can be broken down into three categories:

//

// 1) An error that occurred during scanning. For example, an unterminated literal, or a

// character that was completely not understood.

//

// 2) A token was expected, but was not present. This type of error is commonly produced

// by the 'parseExpected' function.

//

// 3) A token was present that no parsing function was able to consume. This type of error

// only occurs in the 'abortParsingListOrMoveToNextToken' function when the parser

// decides to skip the token.

//

// In all of these cases, we want to mark the next node as having had an error before it.

// With this mark, we can know in incremental settings if this node can be reused, or if

// we have to reparse it. If we don't keep this information around, we may just reuse the

// node. in that event we would then not produce the same errors as we did before, causing

// significant confusion problems.

//

// Note: it is necessary that this value be saved/restored during speculative/lookahead

// parsing. During lookahead parsing, we will often create a node. That node will have

// this value attached, and then this value will be set back to 'false'. If we decide to

// rewind, we must get back to the same value we had prior to the lookahead.

//

// Note: any errors at the end of the file that do not precede a regular node, should get

// attached to the EOF token.

let parseErrorBeforeNextFinishedNode = false;

export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean, scriptKind?: ScriptKind): SourceFile {

scriptKind = ensureScriptKind(fileName, scriptKind);

initializeState(fileName, _sourceText, languageVersion, _syntaxCursor, scriptKind);

const result = parseSourceFileWorker(fileName, languageVersion, setParentNodes, scriptKind);

clearState();

return result;

}

function getLanguageVariant(scriptKind: ScriptKind) {

// .tsx and .jsx files are treated as jsx language variant.

return scriptKind === ScriptKind.TSX || scriptKind === ScriptKind.JSX || scriptKind === ScriptKind.JS ? LanguageVariant.JSX : LanguageVariant.Standard;

}

function initializeState(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, scriptKind: ScriptKind) {

NodeConstructor = objectAllocator.getNodeConstructor();

TokenConstructor = objectAllocator.getTokenConstructor();

IdentifierConstructor = objectAllocator.getIdentifierConstructor();

SourceFileConstructor = objectAllocator.getSourceFileConstructor();

sourceText = _sourceText;

syntaxCursor = _syntaxCursor;

parseDiagnostics = [];

parsingContext = 0;

identifiers = {};

identifierCount = 0;

nodeCount = 0;

contextFlags = scriptKind === ScriptKind.JS || scriptKind === ScriptKind.JSX ? NodeFlags.JavaScriptFile : NodeFlags.None;

parseErrorBeforeNextFinishedNode = false;

// Initialize and prime the scanner before parsing the source elements.

scanner.setText(sourceText);

scanner.setOnError(scanError);

scanner.setScriptTarget(languageVersion);

scanner.setLanguageVariant(getLanguageVariant(scriptKind));

}

function clearState() {

// Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily.

scanner.setText("");

scanner.setOnError(undefined);

// Clear any data. We don't want to accidentally hold onto it for too long.

parseDiagnostics = undefined;

sourceFile = undefined;

identifiers = undefined;

syntaxCursor = undefined;

sourceText = undefined;

}

function parseSourceFileWorker(fileName: string, languageVersion: ScriptTarget, setParentNodes: boolean, scriptKind: ScriptKind): SourceFile {

sourceFile = createSourceFile(fileName, languageVersion, scriptKind);

sourceFile.flags = contextFlags;

// Prime the scanner.

nextToken();

processReferenceComments(sourceFile);

sourceFile.statements = parseList(ParsingContext.SourceElements, parseStatement);

Debug.assert(token() === SyntaxKind.EndOfFileToken);

sourceFile.endOfFileToken = parseTokenNode();

setExternalModuleIndicator(sourceFile);

sourceFile.nodeCount = nodeCount;

sourceFile.identifierCount = identifierCount;

sourceFile.identifiers = identifiers;

sourceFile.parseDiagnostics = parseDiagnostics;

if (setParentNodes) {

fixupParentReferences(sourceFile);

}

return sourceFile;

}

function addJSDocComment<T extends Node>(node: T): T {

if (contextFlags & NodeFlags.JavaScriptFile) {

const comments = getLeadingCommentRangesOfNode(node, sourceFile);

if (comments) {

for (const comment of comments) {

const jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);

if (!jsDocComment) {

continue;

}

if (!node.jsDocComments) {

node.jsDocComments = [];

}

node.jsDocComments.push(jsDocComment);

}

}

}

return node;

}

export function fixupParentReferences(rootNode: Node) {

// normally parent references are set during binding. However, for clients that only need

// a syntax tree, and no semantic features, then the binding process is an unnecessary

// overhead. This functions allows us to set all the parents, without all the expense of

// binding.

let parent: Node = rootNode;

forEachChild(rootNode, visitNode);

return;

function visitNode(n: Node): void {

// walk down setting parents that differ from the parent we think it should be. This

// allows us to quickly bail out of setting parents for subtrees during incremental

// parsing

if (n.parent !== parent) {

n.parent = parent;

const saveParent = parent;

parent = n;

forEachChild(n, visitNode);

if (n.jsDocComments) {

for (const jsDocComment of n.jsDocComments) {

jsDocComment.parent = n;

parent = jsDocComment;

forEachChild(jsDocComment, visitNode);

}

}

parent = saveParent;

}

}

}

function createSourceFile(fileName: string, languageVersion: ScriptTarget, scriptKind: ScriptKind): SourceFile {

// code from createNode is inlined here so createNode won't have to deal with special case of creating source files

// this is quite rare comparing to other nodes and createNode should be as fast as possible

const sourceFile = <SourceFile>new SourceFileConstructor(SyntaxKind.SourceFile, /*pos*/ 0, /* end */ sourceText.length);

nodeCount++;

sourceFile.text = sourceText;

sourceFile.bindDiagnostics = [];

sourceFile.languageVersion = languageVersion;

sourceFile.fileName = normalizePath(fileName);

sourceFile.languageVariant = getLanguageVariant(scriptKind);

sourceFile.isDeclarationFile = fileExtensionIs(sourceFile.fileName, ".d.ts");

sourceFile.scriptKind = scriptKind;

return sourceFile;

}

function setContextFlag(val: boolean, flag: NodeFlags) {

if (val) {

contextFlags |= flag;

}

else {

contextFlags &= ~flag;

}

}

function setDisallowInContext(val: boolean) {

setContextFlag(val, NodeFlags.DisallowInContext);

}

function setYieldContext(val: boolean) {

setContextFlag(val, NodeFlags.YieldContext);

}

function setDecoratorContext(val: boolean) {

setContextFlag(val, NodeFlags.DecoratorContext);

}

function setAwaitContext(val: boolean) {

setContextFlag(val, NodeFlags.AwaitContext);

}

function doOutsideOfContext<T>(context: NodeFlags, func: () => T): T {

// contextFlagsToClear will contain only the context flags that are

// currently set that we need to temporarily clear

// We don't just blindly reset to the previous flags to ensure

// that we do not mutate cached flags for the incremental

// parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and

// HasAggregatedChildData).

const contextFlagsToClear = context & contextFlags;

if (contextFlagsToClear) {

// clear the requested context flags

setContextFlag(/*val*/ false, contextFlagsToClear);

const result = func();

// restore the context flags we just cleared

setContextFlag(/*val*/ true, contextFlagsToClear);

return result;

}

// no need to do anything special as we are not in any of the requested contexts

return func();

}

function doInsideOfContext<T>(context: NodeFlags, func: () => T): T {

// contextFlagsToSet will contain only the context flags that

// are not currently set that we need to temporarily enable.

// We don't just blindly reset to the previous flags to ensure

// that we do not mutate cached flags for the incremental

// parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and

// HasAggregatedChildData).

const contextFlagsToSet = context & ~contextFlags;

if (contextFlagsToSet) {

// set the requested context flags

setContextFlag(/*val*/ true, contextFlagsToSet);

const result = func();

// reset the context flags we just set

setContextFlag(/*val*/ false, contextFlagsToSet);

return result;

}

// no need to do anything special as we are already in all of the requested contexts

return func();

}

function allowInAnd<T>(func: () => T): T {

return doOutsideOfContext(NodeFlags.DisallowInContext, func);

}

function disallowInAnd<T>(func: () => T): T {

return doInsideOfContext(NodeFlags.DisallowInContext, func);

}

function doInYieldContext<T>(func: () => T): T {

return doInsideOfContext(NodeFlags.YieldContext, func);

}

function doInDecoratorContext<T>(func: () => T): T {

return doInsideOfContext(NodeFlags.DecoratorContext, func);

}

function doInAwaitContext<T>(func: () => T): T {

return doInsideOfContext(NodeFlags.AwaitContext, func);

}

function doOutsideOfAwaitContext<T>(func: () => T): T {

return doOutsideOfContext(NodeFlags.AwaitContext, func);

}

function doInYieldAndAwaitContext<T>(func: () => T): T {

return doInsideOfContext(NodeFlags.YieldContext | NodeFlags.AwaitContext, func);

}

function inContext(flags: NodeFlags) {

return (contextFlags & flags) !== 0;

}

function inYieldContext() {

return inContext(NodeFlags.YieldContext);

}

function inDisallowInContext() {

return inContext(NodeFlags.DisallowInContext);

}

function inDecoratorContext() {

return inContext(NodeFlags.DecoratorContext);

}

function inAwaitContext() {

return inContext(NodeFlags.AwaitContext);

}

function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void {

const start = scanner.getTokenPos();

const length = scanner.getTextPos() - start;

parseErrorAtPosition(start, length, message, arg0);

}

function parseErrorAtPosition(start: number, length: number, message: DiagnosticMessage, arg0?: any): void {

// Don't report another error if it would just be at the same position as the last error.

const lastError = lastOrUndefined(parseDiagnostics);

if (!lastError || start !== lastError.start) {

parseDiagnostics.push(createFileDiagnostic(sourceFile, start, length, message, arg0));

}

// Mark that we've encountered an error. We'll set an appropriate bit on the next

// node we finish so that it can't be reused incrementally.

parseErrorBeforeNextFinishedNode = true;

}

function scanError(message: DiagnosticMessage, length?: number) {

const pos = scanner.getTextPos();

parseErrorAtPosition(pos, length || 0, message);

}

function getNodePos(): number {

return scanner.getStartPos();

}

function getNodeEnd(): number {

return scanner.getStartPos();

}

// Use this function to access the current token instead of reading the currentToken

// variable. Since function results aren't narrowed in control flow analysis, this ensures

// that the type checker doesn't make wrong assumptions about the type of the current

// token (e.g. a call to nextToken() changes the current token but the checker doesn't

// reason about this side effect). Mainstream VMs inline simple functions like this, so

// there is no performance penalty.

function token(): SyntaxKind {

return currentToken;

}

function nextToken(): SyntaxKind {

return currentToken = scanner.scan();

}

function reScanGreaterToken(): SyntaxKind {

return currentToken = scanner.reScanGreaterToken();

}

function reScanSlashToken(): SyntaxKind {

return currentToken = scanner.reScanSlashToken();

}

function reScanTemplateToken(): SyntaxKind {

return currentToken = scanner.reScanTemplateToken();

}

function scanJsxIdentifier(): SyntaxKind {

return currentToken = scanner.scanJsxIdentifier();

}

function scanJsxText(): SyntaxKind {

return currentToken = scanner.scanJsxToken();

}

function speculationHelper<T>(callback: () => T, isLookAhead: boolean): T {

// Keep track of the state we'll need to rollback to if lookahead fails (or if the

// caller asked us to always reset our state).

const saveToken = currentToken;

const saveParseDiagnosticsLength = parseDiagnostics.length;

const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;

// Note: it is not actually necessary to save/restore the context flags here. That's

// because the saving/restoring of these flags happens naturally through the recursive

// descent nature of our parser. However, we still store this here just so we can

// assert that that invariant holds.

const saveContextFlags = contextFlags;

// If we're only looking ahead, then tell the scanner to only lookahead as well.

// Otherwise, if we're actually speculatively parsing, then tell the scanner to do the

// same.

const result = isLookAhead

? scanner.lookAhead(callback)

: scanner.tryScan(callback);

Debug.assert(saveContextFlags === contextFlags);

// If our callback returned something 'falsy' or we're just looking ahead,

// then unconditionally restore us to where we were.

if (!result || isLookAhead) {

currentToken = saveToken;

parseDiagnostics.length = saveParseDiagnosticsLength;

parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;

}

return result;

}

/** Invokes the provided callback then unconditionally restores the parser to the state it

* was in immediately prior to invoking the callback. The result of invoking the callback

* is returned from this function.

*/

function lookAhead<T>(callback: () => T): T {

return speculationHelper(callback, /*isLookAhead*/ true);

}

/** Invokes the provided callback. If the callback returns something falsy, then it restores

* the parser to the state it was in immediately prior to invoking the callback. If the

* callback returns something truthy, then the parser state is not rolled back. The result

* of invoking the callback is returned from this function.

*/

function tryParse<T>(callback: () => T): T {

return speculationHelper(callback, /*isLookAhead*/ false);

}

// Ignore strict mode flag because we will report an error in type checker instead.

function isIdentifier(): boolean {

if (token() === SyntaxKind.Identifier) {

return true;

}

// If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is

// considered a keyword and is not an identifier.

if (token() === SyntaxKind.YieldKeyword && inYieldContext()) {

return false;

}

// If we have a 'await' keyword, and we're in the [Await] context, then 'await' is

// considered a keyword and is not an identifier.

if (token() === SyntaxKind.AwaitKeyword && inAwaitContext()) {

return false;

}

return token() > SyntaxKind.LastReservedWord;

}

function parseExpected(kind: SyntaxKind, diagnosticMessage?: DiagnosticMessage, shouldAdvance = true): boolean {

if (token() === kind) {

if (shouldAdvance) {

nextToken();

}

return true;

}

// Report specific message if provided with one. Otherwise, report generic fallback message.

if (diagnosticMessage) {

parseErrorAtCurrentToken(diagnosticMessage);

}

else {

parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));

}

return false;

}

function parseOptional(t: SyntaxKind): boolean {

if (token() === t) {

nextToken();

return true;

}

return false;

}

function parseOptionalToken(t: SyntaxKind): Node {