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

/* @internal */

namespace ts {

export const externalHelpersModuleNameText = "tslib";

export interface ReferencePathMatchResult {

fileReference?: FileReference;

diagnosticMessage?: DiagnosticMessage;

isNoDefaultLib?: boolean;

isTypeReferenceDirective?: boolean;

}

export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration {

const declarations = symbol.declarations;

if (declarations) {

for (const declaration of declarations) {

if (declaration.kind === kind) {

return declaration;

}

}

}

return undefined;

}

export interface StringSymbolWriter extends SymbolWriter {

string(): string;

}

export interface EmitHost extends ScriptReferenceHost {

getSourceFiles(): SourceFile[];

/* @internal */

isSourceFileFromExternalLibrary(file: SourceFile): boolean;

getCommonSourceDirectory(): string;

getCanonicalFileName(fileName: string): string;

getNewLine(): string;

isEmitBlocked(emitFileName: string): boolean;

writeFile: WriteFileCallback;

}

// Pool writers to avoid needing to allocate them for every symbol we write.

const stringWriters: StringSymbolWriter[] = [];

export function getSingleLineStringWriter(): StringSymbolWriter {

if (stringWriters.length === 0) {

let str = "";

const writeText: (text: string) => void = text => str += text;

return {

string: () => str,

writeKeyword: writeText,

writeOperator: writeText,

writePunctuation: writeText,

writeSpace: writeText,

writeStringLiteral: writeText,

writeParameter: writeText,

writeSymbol: writeText,

// Completely ignore indentation for string writers. And map newlines to

// a single space.

writeLine: () => str += " ",

increaseIndent: () => { },

decreaseIndent: () => { },

clear: () => str = "",

trackSymbol: () => { },

reportInaccessibleThisError: () => { }

};

}

return stringWriters.pop();

}

export function releaseStringWriter(writer: StringSymbolWriter) {

writer.clear();

stringWriters.push(writer);

}

export function getFullWidth(node: Node) {

return node.end - node.pos;

}

export function arrayIsEqualTo<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, equaler?: (a: T, b: T) => boolean): boolean {

if (!array1 || !array2) {

return array1 === array2;

}

if (array1.length !== array2.length) {

return false;

}

for (let i = 0; i < array1.length; i++) {

const equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];

if (!equals) {

return false;

}

}

return true;

}

export function hasResolvedModule(sourceFile: SourceFile, moduleNameText: string): boolean {

return !!(sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules[moduleNameText]);

}

export function getResolvedModule(sourceFile: SourceFile, moduleNameText: string): ResolvedModule {

return hasResolvedModule(sourceFile, moduleNameText) ? sourceFile.resolvedModules[moduleNameText] : undefined;

}

export function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModule): void {

if (!sourceFile.resolvedModules) {

sourceFile.resolvedModules = createMap<ResolvedModule>();

}

sourceFile.resolvedModules[moduleNameText] = resolvedModule;

}

export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective): void {

if (!sourceFile.resolvedTypeReferenceDirectiveNames) {

sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();

}

sourceFile.resolvedTypeReferenceDirectiveNames[typeReferenceDirectiveName] = resolvedTypeReferenceDirective;

}

/* @internal */

export function moduleResolutionIsEqualTo(oldResolution: ResolvedModule, newResolution: ResolvedModule): boolean {

return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport;

}

/* @internal */

export function typeDirectiveIsEqualTo(oldResolution: ResolvedTypeReferenceDirective, newResolution: ResolvedTypeReferenceDirective): boolean {

return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary;

}

/* @internal */

export function hasChangesInResolutions<T>(names: string[], newResolutions: T[], oldResolutions: Map<T>, comparer: (oldResolution: T, newResolution: T) => boolean): boolean {

if (names.length !== newResolutions.length) {

return false;

}

for (let i = 0; i < names.length; i++) {

const newResolution = newResolutions[i];

const oldResolution = oldResolutions && oldResolutions[names[i]];

const changed =

oldResolution

? !newResolution || !comparer(oldResolution, newResolution)

: newResolution;

if (changed) {

return true;

}

}

return false;

}

// Returns true if this node contains a parse error anywhere underneath it.

export function containsParseError(node: Node): boolean {

aggregateChildData(node);

return (node.flags & NodeFlags.ThisNodeOrAnySubNodesHasError) !== 0;

}

function aggregateChildData(node: Node): void {

if (!(node.flags & NodeFlags.HasAggregatedChildData)) {

// A node is considered to contain a parse error if:

// a) the parser explicitly marked that it had an error

// b) any of it's children reported that it had an error.

const thisNodeOrAnySubNodesHasError = ((node.flags & NodeFlags.ThisNodeHasError) !== 0) ||

forEachChild(node, containsParseError);

// If so, mark ourselves accordingly.

if (thisNodeOrAnySubNodesHasError) {

node.flags |= NodeFlags.ThisNodeOrAnySubNodesHasError;

}

// Also mark that we've propagated the child information to this node. This way we can

// always consult the bit directly on this node without needing to check its children

// again.

node.flags |= NodeFlags.HasAggregatedChildData;

}

}

export function getSourceFileOfNode(node: Node): SourceFile {

while (node && node.kind !== SyntaxKind.SourceFile) {

node = node.parent;

}

return <SourceFile>node;

}

export function isStatementWithLocals(node: Node) {

switch (node.kind) {

case SyntaxKind.Block:

case SyntaxKind.CaseBlock:

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

return true;

}

return false;

}

export function getStartPositionOfLine(line: number, sourceFile: SourceFile): number {

Debug.assert(line >= 0);

return getLineStarts(sourceFile)[line];

}

// This is a useful function for debugging purposes.

export function nodePosToString(node: Node): string {

const file = getSourceFileOfNode(node);

const loc = getLineAndCharacterOfPosition(file, node.pos);

return `${ file.fileName }(${ loc.line + 1 },${ loc.character + 1 })`;

}

export function getStartPosOfNode(node: Node): number {

return node.pos;

}

export function isDefined(value: any): boolean {

return value !== undefined;

}

export function getEndLinePosition(line: number, sourceFile: SourceFile): number {

Debug.assert(line >= 0);

const lineStarts = getLineStarts(sourceFile);

const lineIndex = line;

const sourceText = sourceFile.text;

if (lineIndex + 1 === lineStarts.length) {

// last line - return EOF

return sourceText.length - 1;

}

else {

// current line start

const start = lineStarts[lineIndex];

// take the start position of the next line - 1 = it should be some line break

let pos = lineStarts[lineIndex + 1] - 1;

Debug.assert(isLineBreak(sourceText.charCodeAt(pos)));

// walk backwards skipping line breaks, stop the the beginning of current line.

// i.e:

// <some text>

// $ <- end of line for this position should match the start position

while (start <= pos && isLineBreak(sourceText.charCodeAt(pos))) {

pos--;

}

return pos;

}

}

// Returns true if this node is missing from the actual source code. A 'missing' node is different

// from 'undefined/defined'. When a node is undefined (which can happen for optional nodes

// in the tree), it is definitely missing. However, a node may be defined, but still be

// missing. This happens whenever the parser knows it needs to parse something, but can't

// get anything in the source code that it expects at that location. For example:

//

// let a: ;

//

// Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source

// code). So the parser will attempt to parse out a type, and will create an actual node.

// However, this node will be 'missing' in the sense that no actual source-code/tokens are

// contained within it.

export function nodeIsMissing(node: Node) {

if (node === undefined) {

return true;

}

return node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFileToken;

}

export function nodeIsPresent(node: Node) {

return !nodeIsMissing(node);

}

export function getTokenPosOfNode(node: Node, sourceFile?: SourceFile, includeJsDocComment?: boolean): number {

// With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*

// want to skip trivia because this will launch us forward to the next token.

if (nodeIsMissing(node)) {

return node.pos;

}

if (isJSDocNode(node)) {

return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);

}

if (includeJsDocComment && node.jsDocComments && node.jsDocComments.length > 0) {

return getTokenPosOfNode(node.jsDocComments[0]);

}

// For a syntax list, it is possible that one of its children has JSDocComment nodes, while

// the syntax list itself considers them as normal trivia. Therefore if we simply skip

// trivia for the list, we may have skipped the JSDocComment as well. So we should process its

// first child to determine the actual position of its first token.

if (node.kind === SyntaxKind.SyntaxList && (<SyntaxList>node)._children.length > 0) {

return getTokenPosOfNode((<SyntaxList>node)._children[0], sourceFile, includeJsDocComment);

}

return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);

}

export function isJSDocNode(node: Node) {

return node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode;

}

export function isJSDocTag(node: Node) {

return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;

}

export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {

if (nodeIsMissing(node) || !node.decorators) {

return getTokenPosOfNode(node, sourceFile);

}

return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end);

}

export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia = false): string {

if (nodeIsMissing(node)) {

return "";

}

const text = sourceFile.text;

return text.substring(includeTrivia ? node.pos : skipTrivia(text, node.pos), node.end);

}

export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string {

if (nodeIsMissing(node)) {

return "";

}

return sourceText.substring(skipTrivia(sourceText, node.pos), node.end);

}

export function getTextOfNode(node: Node, includeTrivia = false): string {

return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);

}

export function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile, languageVersion: ScriptTarget) {

// Any template literal or string literal with an extended escape

// (e.g. "\u{0067}") will need to be downleveled as a escaped string literal.

if (languageVersion < ScriptTarget.ES6 && (isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {

return getQuotedEscapedLiteralText('"', node.text, '"');

}

// If we don't need to downlevel and we can reach the original source text using

// the node's parent reference, then simply get the text as it was originally written.

if (!nodeIsSynthesized(node) && node.parent) {

const text = getSourceTextOfNodeFromSourceFile(sourceFile, node);

if (languageVersion < ScriptTarget.ES6 && isBinaryOrOctalIntegerLiteral(node, text)) {

return node.text;

}

return text;

}

// If we can't reach the original source text, use the canonical form if it's a number,

// or an escaped quoted form of the original text if it's string-like.

switch (node.kind) {

case SyntaxKind.StringLiteral:

return getQuotedEscapedLiteralText('"', node.text, '"');

case SyntaxKind.NoSubstitutionTemplateLiteral:

return getQuotedEscapedLiteralText("`", node.text, "`");

case SyntaxKind.TemplateHead:

return getQuotedEscapedLiteralText("`", node.text, "${");

case SyntaxKind.TemplateMiddle:

return getQuotedEscapedLiteralText("}", node.text, "${");

case SyntaxKind.TemplateTail:

return getQuotedEscapedLiteralText("}", node.text, "`");

case SyntaxKind.NumericLiteral:

return node.text;

}

Debug.fail(`Literal kind '${node.kind}' not accounted for.`);

}

export function isBinaryOrOctalIntegerLiteral(node: LiteralLikeNode, text: string) {

if (node.kind === SyntaxKind.NumericLiteral && text.length > 1) {

switch (text.charCodeAt(1)) {

case CharacterCodes.b:

case CharacterCodes.B:

case CharacterCodes.o:

case CharacterCodes.O:

return true;

}

}

return false;

}

function getQuotedEscapedLiteralText(leftQuote: string, text: string, rightQuote: string) {

return leftQuote + escapeNonAsciiCharacters(escapeString(text)) + rightQuote;

}

// Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__'

export function escapeIdentifier(identifier: string): string {

return identifier.length >= 2 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ ? "_" + identifier : identifier;

}

// Remove extra underscore from escaped identifier

export function unescapeIdentifier(identifier: string): string {

return identifier.length >= 3 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ && identifier.charCodeAt(2) === CharacterCodes._ ? identifier.substr(1) : identifier;

}

// Make an identifier from an external module name by extracting the string after the last "/" and replacing

// all non-alphanumeric characters with underscores

export function makeIdentifierFromModuleName(moduleName: string): string {

return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");

}

export function isBlockOrCatchScoped(declaration: Declaration) {

return (getCombinedNodeFlags(declaration) & NodeFlags.BlockScoped) !== 0 ||

isCatchClauseVariableDeclaration(declaration);

}

export function isAmbientModule(node: Node): boolean {

return node && node.kind === SyntaxKind.ModuleDeclaration &&

((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(<ModuleDeclaration>node));

}

export function isShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean {

return isShorthandAmbientModule(moduleSymbol.valueDeclaration);

}

function isShorthandAmbientModule(node: Node): boolean {

// The only kind of module that can be missing a body is a shorthand ambient module.

return node.kind === SyntaxKind.ModuleDeclaration && (!(<ModuleDeclaration>node).body);

}

export function isBlockScopedContainerTopLevel(node: Node): boolean {

return node.kind === SyntaxKind.SourceFile ||

node.kind === SyntaxKind.ModuleDeclaration ||

isFunctionLike(node);

}

export function isGlobalScopeAugmentation(module: ModuleDeclaration): boolean {

return !!(module.flags & NodeFlags.GlobalAugmentation);

}

export function isExternalModuleAugmentation(node: Node): boolean {

// external module augmentation is a ambient module declaration that is either:

// - defined in the top level scope and source file is an external module

// - defined inside ambient module declaration located in the top level scope and source file not an external module

if (!node || !isAmbientModule(node)) {

return false;

}

switch (node.parent.kind) {

case SyntaxKind.SourceFile:

return isExternalModule(<SourceFile>node.parent);

case SyntaxKind.ModuleBlock:

return isAmbientModule(node.parent.parent) && !isExternalModule(<SourceFile>node.parent.parent.parent);

}

return false;

}

export function isBlockScope(node: Node, parentNode: Node) {

switch (node.kind) {

case SyntaxKind.SourceFile:

case SyntaxKind.CaseBlock:

case SyntaxKind.CatchClause:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

case SyntaxKind.Constructor:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction:

return true;

case SyntaxKind.Block:

// function block is not considered block-scope container

// see comment in binder.ts: bind(...), case for SyntaxKind.Block

return parentNode && !isFunctionLike(parentNode);

}

return false;

}

// Gets the nearest enclosing block scope container that has the provided node

// as a descendant, that is not the provided node.

export function getEnclosingBlockScopeContainer(node: Node): Node {

let current = node.parent;

while (current) {

if (isBlockScope(current, current.parent)) {

return current;

}

current = current.parent;

}

}

export function isCatchClauseVariableDeclaration(declaration: Declaration) {

return declaration &&

declaration.kind === SyntaxKind.VariableDeclaration &&

declaration.parent &&

declaration.parent.kind === SyntaxKind.CatchClause;

}

// Return display name of an identifier

// Computed property names will just be emitted as "[<expr>]", where <expr> is the source

// text of the expression in the computed property.

export function declarationNameToString(name: DeclarationName) {

return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);

}

export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic {

const sourceFile = getSourceFileOfNode(node);

const span = getErrorSpanForNode(sourceFile, node);

return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2);

}

export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic {

const sourceFile = getSourceFileOfNode(node);

const span = getErrorSpanForNode(sourceFile, node);

return {

file: sourceFile,

start: span.start,

length: span.length,

code: messageChain.code,

category: messageChain.category,

messageText: messageChain.next ? messageChain : messageChain.messageText

};

}

export function getSpanOfTokenAtPosition(sourceFile: SourceFile, pos: number): TextSpan {

const scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos);

scanner.scan();

const start = scanner.getTokenPos();

return createTextSpanFromBounds(start, scanner.getTextPos());

}

function getErrorSpanForArrowFunction(sourceFile: SourceFile, node: ArrowFunction): TextSpan {

const pos = skipTrivia(sourceFile.text, node.pos);

if (node.body && node.body.kind === SyntaxKind.Block) {

const { line: startLine } = getLineAndCharacterOfPosition(sourceFile, node.body.pos);

const { line: endLine } = getLineAndCharacterOfPosition(sourceFile, node.body.end);

if (startLine < endLine) {

// The arrow function spans multiple lines,

// make the error span be the first line, inclusive.

return createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1);

}

}

return createTextSpanFromBounds(pos, node.end);

}

export function getErrorSpanForNode(sourceFile: SourceFile, node: Node): TextSpan {

let errorNode = node;

switch (node.kind) {

case SyntaxKind.SourceFile:

let pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);

if (pos === sourceFile.text.length) {

// file is empty - return span for the beginning of the file

return createTextSpan(0, 0);

}

return getSpanOfTokenAtPosition(sourceFile, pos);

// This list is a work in progress. Add missing node kinds to improve their error

// spans.

case SyntaxKind.VariableDeclaration:

case SyntaxKind.BindingElement:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.EnumDeclaration:

case SyntaxKind.EnumMember:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.TypeAliasDeclaration:

errorNode = (<Declaration>node).name;

break;

case SyntaxKind.ArrowFunction:

return getErrorSpanForArrowFunction(sourceFile, <ArrowFunction>node);

}

if (errorNode === undefined) {

// If we don't have a better node, then just set the error on the first token of

// construct.

return getSpanOfTokenAtPosition(sourceFile, node.pos);

}

const pos = nodeIsMissing(errorNode)

? errorNode.pos

: skipTrivia(sourceFile.text, errorNode.pos);

return createTextSpanFromBounds(pos, errorNode.end);

}

export function isExternalOrCommonJsModule(file: SourceFile): boolean {

return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined;

}

export function isDeclarationFile(file: SourceFile): boolean {

return file.isDeclarationFile;

}

export function isConstEnumDeclaration(node: Node): boolean {

return node.kind === SyntaxKind.EnumDeclaration && isConst(node);

}

export function isConst(node: Node): boolean {

return !!(getCombinedNodeFlags(node) & NodeFlags.Const)

|| !!(getCombinedModifierFlags(node) & ModifierFlags.Const);

}

export function isLet(node: Node): boolean {

return !!(getCombinedNodeFlags(node) & NodeFlags.Let);

}

export function isSuperCallExpression(n: Node): boolean {

return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.SuperKeyword;

}

export function isPrologueDirective(node: Node): boolean {

return node.kind === SyntaxKind.ExpressionStatement && (<ExpressionStatement>node).expression.kind === SyntaxKind.StringLiteral;

}

export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile) {

return getLeadingCommentRanges(sourceFileOfNode.text, node.pos);

}

export function getLeadingCommentRangesOfNodeFromText(node: Node, text: string) {

return getLeadingCommentRanges(text, node.pos);

}

export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) {

return getJsDocCommentsFromText(node, sourceFileOfNode.text);

}

export function getJsDocCommentsFromText(node: Node, text: string) {

const commentRanges = (node.kind === SyntaxKind.Parameter ||

node.kind === SyntaxKind.TypeParameter ||

node.kind === SyntaxKind.FunctionExpression ||

node.kind === SyntaxKind.ArrowFunction) ?

concatenate(getTrailingCommentRanges(text, node.pos), getLeadingCommentRanges(text, node.pos)) :

getLeadingCommentRangesOfNodeFromText(node, text);

return filter(commentRanges, isJsDocComment);

function isJsDocComment(comment: CommentRange) {

// True if the comment starts with '/**' but not if it is '/**/'

return text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&

text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&

text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash;

}

}

export let fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;

export let fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)('|")(.+?)\2.*?\/>/;

export let fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)('|")(.+?)\2.*?\/>/;

export function isPartOfTypeNode(node: Node): boolean {

if (SyntaxKind.FirstTypeNode <= node.kind && node.kind <= SyntaxKind.LastTypeNode) {

return true;

}

switch (node.kind) {

case SyntaxKind.AnyKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.SymbolKeyword:

case SyntaxKind.UndefinedKeyword:

case SyntaxKind.NeverKeyword:

return true;

case SyntaxKind.VoidKeyword:

return node.parent.kind !== SyntaxKind.VoidExpression;

case SyntaxKind.ExpressionWithTypeArguments:

return !isExpressionWithTypeArgumentsInClassExtendsClause(node);

// Identifiers and qualified names may be type nodes, depending on their context. Climb

// above them to find the lowest container

case SyntaxKind.Identifier:

// If the identifier is the RHS of a qualified name, then it's a type iff its parent is.

if (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) {

node = node.parent;

}

else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node) {

node = node.parent;

}

// At this point, node is either a qualified name or an identifier

Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression,

"'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");

case SyntaxKind.QualifiedName:

case SyntaxKind.PropertyAccessExpression:

case SyntaxKind.ThisKeyword:

let parent = node.parent;

if (parent.kind === SyntaxKind.TypeQuery) {

return false;

}

// Do not recursively call isPartOfTypeNode on the parent. In the example:

//

// let a: A.B.C;

//

// Calling isPartOfTypeNode would consider the qualified name A.B a type node. Only C or

// A.B.C is a type node.

if (SyntaxKind.FirstTypeNode <= parent.kind && parent.kind <= SyntaxKind.LastTypeNode) {

return true;

}

switch (parent.kind) {

case SyntaxKind.ExpressionWithTypeArguments:

return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);

case SyntaxKind.TypeParameter:

return node === (<TypeParameterDeclaration>parent).constraint;

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

case SyntaxKind.Parameter:

case SyntaxKind.VariableDeclaration:

return node === (<VariableLikeDeclaration>parent).type;

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction:

case SyntaxKind.Constructor:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return node === (<FunctionLikeDeclaration>parent).type;

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.IndexSignature:

return node === (<SignatureDeclaration>parent).type;

case SyntaxKind.TypeAssertionExpression:

return node === (<TypeAssertion>parent).type;

case SyntaxKind.CallExpression:

case SyntaxKind.NewExpression:

return (<CallExpression>parent).typeArguments && indexOf((<CallExpression>parent).typeArguments, node) >= 0;

case SyntaxKind.TaggedTemplateExpression:

// TODO (drosen): TaggedTemplateExpressions may eventually support type arguments.

return false;

}

}

return false;

}

// Warning: This has the same semantics as the forEach family of functions,

// in that traversal terminates in the event that 'visitor' supplies a truthy value.

export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {

return traverse(body);

function traverse(node: Node): T {

switch (node.kind) {

case SyntaxKind.ReturnStatement:

return visitor(<ReturnStatement>node);

case SyntaxKind.CaseBlock:

case SyntaxKind.Block:

case SyntaxKind.IfStatement:

case SyntaxKind.DoStatement:

case SyntaxKind.WhileStatement:

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

case SyntaxKind.WithStatement:

case SyntaxKind.SwitchStatement:

case SyntaxKind.CaseClause:

case SyntaxKind.DefaultClause:

case SyntaxKind.LabeledStatement:

case SyntaxKind.TryStatement:

case SyntaxKind.CatchClause:

return forEachChild(node, traverse);

}

}

}

export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpression) => void): void {

return traverse(body);

function traverse(node: Node): void {

switch (node.kind) {

case SyntaxKind.YieldExpression:

visitor(<YieldExpression>node);

let operand = (<YieldExpression>node).expression;

if (operand) {

traverse(operand);

}

case SyntaxKind.EnumDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

// These are not allowed inside a generator now, but eventually they may be allowed

// as local types. Regardless, any yield statements contained within them should be

// skipped in this traversal.

return;

default:

if (isFunctionLike(node)) {

const name = (<FunctionLikeDeclaration>node).name;

if (name && name.kind === SyntaxKind.ComputedPropertyName) {

// Note that we will not include methods/accessors of a class because they would require

// first descending into the class. This is by design.

traverse((<ComputedPropertyName>name).expression);

return;

}

}

else if (!isPartOfTypeNode(node)) {

// This is the general case, which should include mostly expressions and statements.

// Also includes NodeArrays.

forEachChild(node, traverse);

}

}

}

}

export function isVariableLike(node: Node): node is VariableLikeDeclaration {

if (node) {

switch (node.kind) {

case SyntaxKind.BindingElement:

case SyntaxKind.EnumMember:

case SyntaxKind.Parameter:

case SyntaxKind.PropertyAssignment:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

case SyntaxKind.ShorthandPropertyAssignment:

case SyntaxKind.VariableDeclaration:

return true;

}

}

return false;

}

export function isAccessor(node: Node): node is AccessorDeclaration {

return node && (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor);

}

export function isClassLike(node: Node): node is ClassLikeDeclaration {

return node && (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression);

}

export function isFunctionLike(node: Node): node is FunctionLikeDeclaration {

return node && isFunctionLikeKind(node.kind);

}

export function isFunctionLikeKind(kind: SyntaxKind): boolean {

switch (kind) {

case SyntaxKind.Constructor:

case SyntaxKind.FunctionExpression:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ArrowFunction:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.IndexSignature:

case SyntaxKind.FunctionType:

case SyntaxKind.ConstructorType:

return true;

}

return false;

}

export function introducesArgumentsExoticObject(node: Node) {

switch (node.kind) {

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

return true;

}

return false;

}

export function isIterationStatement(node: Node, lookInLabeledStatements: boolean): node is IterationStatement {

switch (node.kind) {

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

case SyntaxKind.DoStatement:

case SyntaxKind.WhileStatement:

return true;

case SyntaxKind.LabeledStatement:

return lookInLabeledStatements && isIterationStatement((<LabeledStatement>node).statement, lookInLabeledStatements);

}

return false;

}

export function isFunctionBlock(node: Node) {

return node && node.kind === SyntaxKind.Block && isFunctionLike(node.parent);

}

export function isObjectLiteralMethod(node: Node): node is MethodDeclaration {

return node && node.kind === SyntaxKind.MethodDeclaration && node.parent.kind === SyntaxKind.ObjectLiteralExpression;

}

export function isIdentifierTypePredicate(predicate: TypePredicate): predicate is IdentifierTypePredicate {

return predicate && predicate.kind === TypePredicateKind.Identifier;

}

export function isThisTypePredicate(predicate: TypePredicate): predicate is ThisTypePredicate {

return predicate && predicate.kind === TypePredicateKind.This;

}

export function getContainingFunction(node: Node): FunctionLikeDeclaration {

while (true) {

node = node.parent;

if (!node || isFunctionLike(node)) {

return <FunctionLikeDeclaration>node;

}

}

}

export function getContainingClass(node: Node): ClassLikeDeclaration {

while (true) {

node = node.parent;

if (!node || isClassLike(node)) {

return <ClassLikeDeclaration>node;

}

}

}

export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node {

while (true) {

node = node.parent;

if (!node) {

return undefined;

}

switch (node.kind) {

case SyntaxKind.ComputedPropertyName:

// If the grandparent node is an object literal (as opposed to a class),

// then the computed property is not a 'this' container.

// A computed property name in a class needs to be a this container

// so that we can error on it.

if (isClassLike(node.parent.parent)) {

return node;

}

// If this is a computed property, then the parent should not

// make it a this container. The parent might be a property

// in an object literal, like a method or accessor. But in order for

// such a parent to be a this container, the reference must be in

// the *body* of the container.

node = node.parent;

break;

case SyntaxKind.Decorator:

// Decorators are always applied outside of the body of a class or method.

if (node.parent.kind === SyntaxKind.Parameter && isClassElement(node.parent.parent)) {

// If the decorator's parent is a Parameter, we resolve the this container from

// the grandparent class declaration.

node = node.parent.parent;

}

else if (isClassElement(node.parent)) {

// If the decorator's parent is a class element, we resolve the 'this' container

// from the parent class declaration.

node = node.parent;

}

break;

case SyntaxKind.ArrowFunction:

if (!includeArrowFunctions) {

continue;

}

// Fall through

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.IndexSignature:

case SyntaxKind.EnumDeclaration:

case SyntaxKind.SourceFile:

return node;

}

}

}

/**

* Given an super call/property node, returns the closest node where

* - a super call/property access is legal in the node and not legal in the parent node the node.

* i.e. super call is legal in constructor but not legal in the class body.

* - the container is an arrow function (so caller might need to call getSuperContainer again in case it needs to climb higher)

* - a super call/property is definitely illegal in the container (but might be legal in some subnode)

* i.e. super property access is illegal in function declaration but can be legal in the statement list

*/

export function getSuperContainer(node: Node, stopOnFunctions: boolean): Node {

while (true) {

node = node.parent;

if (!node) {

return node;

}

switch (node.kind) {

case SyntaxKind.ComputedPropertyName:

node = node.parent;