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

/* @internal */

namespace ts {

export const emptyArray: never[] = [] as never[];

export const resolvingEmptyArray: never[] = [] as never[];

export const emptyMap: ReadonlyMap<never> = createMap<never>();

export const externalHelpersModuleNameText = "tslib";

export interface ReferencePathMatchResult {

fileReference?: FileReference;

diagnosticMessage?: DiagnosticMessage;

isNoDefaultLib?: boolean;

isTypeReferenceDirective?: boolean;

}

export function getDeclarationOfKind<T extends Declaration>(symbol: Symbol, kind: T["kind"]): T {

const declarations = symbol.declarations;

if (declarations) {

for (const declaration of declarations) {

if (declaration.kind === kind) {

return declaration as T;

}

}

}

return undefined;

}

export interface StringSymbolWriter extends SymbolWriter {

string(): string;

}

const stringWriter = createSingleLineStringWriter();

function createSingleLineStringWriter(): StringSymbolWriter {

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,

writeProperty: writeText,

writeSymbol: writeText,

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

// a single space.

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

increaseIndent: noop,

decreaseIndent: noop,

clear: () => str = "",

trackSymbol: noop,

reportInaccessibleThisError: noop,

reportInaccessibleUniqueSymbolError: noop,

reportPrivateInBaseOfClassExpression: noop,

};

}

export function usingSingleLineStringWriter(action: (writer: StringSymbolWriter) => void): string {

const oldString = stringWriter.string();

try {

action(stringWriter);

return stringWriter.string();

}

finally {

stringWriter.clear();

stringWriter.writeKeyword(oldString);

}

}

export function getFullWidth(node: Node) {

return node.end - node.pos;

}

export function getResolvedModule(sourceFile: SourceFile, moduleNameText: string): ResolvedModuleFull | undefined {

return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText);

}

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

if (!sourceFile.resolvedModules) {

sourceFile.resolvedModules = createMap<ResolvedModuleFull>();

}

sourceFile.resolvedModules.set(moduleNameText, resolvedModule);

}

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

if (!sourceFile.resolvedTypeReferenceDirectiveNames) {

sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();

}

sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective);

}

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

return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport &&

oldResolution.extension === newResolution.extension &&

oldResolution.resolvedFileName === newResolution.resolvedFileName &&

oldResolution.originalPath === newResolution.originalPath &&

packageIdIsEqual(oldResolution.packageId, newResolution.packageId);

}

function packageIdIsEqual(a: PackageId | undefined, b: PackageId | undefined): boolean {

return a === b || a && b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;

}

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

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

}

export function hasChangesInResolutions<T>(

names: ReadonlyArray<string>,

newResolutions: ReadonlyArray<T>,

oldResolutions: ReadonlyMap<T>,

comparer: (oldResolution: T, newResolution: T) => boolean): boolean {

Debug.assert(names.length === newResolutions.length);

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

const newResolution = newResolutions[i];

const oldResolution = oldResolutions && oldResolutions.get(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: SourceFileLike): 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 getEndLinePosition(line: number, sourceFile: SourceFileLike): 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);

}

/**

* Determine if the given comment is a triple-slash

*

* @return true if the comment is a triple-slash comment else false

*/

export function isRecognizedTripleSlashComment(text: string, commentPos: number, commentEnd: number) {

// Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text

// so that we don't end up computing comment string and doing match for all // comments

if (text.charCodeAt(commentPos + 1) === CharacterCodes.slash &&

commentPos + 2 < commentEnd &&

text.charCodeAt(commentPos + 2) === CharacterCodes.slash) {

const textSubStr = text.substring(commentPos, commentEnd);

return textSubStr.match(fullTripleSlashReferencePathRegEx) ||

textSubStr.match(fullTripleSlashAMDReferencePathRegEx) ||

textSubStr.match(fullTripleSlashReferenceTypeReferenceDirectiveRegEx) ||

textSubStr.match(defaultLibReferenceRegEx) ?

true : false;

}

return false;

}

export function isPinnedComment(text: string, comment: CommentRange) {

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

text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;

}

export function getTokenPosOfNode(node: Node, sourceFile?: SourceFileLike, includeJsDoc?: 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 (includeJsDoc && hasJSDocNodes(node)) {

return getTokenPosOfNode(node.jsDoc[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, includeJsDoc);

}

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

}

export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFileLike): 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);

}

function getPos(range: Node) {

return range.pos;

}

/**

* Note: it is expected that the `nodeArray` and the `node` are within the same file.

* For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work.

*/

export function indexOfNode(nodeArray: ReadonlyArray<Node>, node: Node) {

return binarySearch(nodeArray, node, getPos, compareValues);

}

/**

* Gets flags that control emit behavior of a node.

*/

export function getEmitFlags(node: Node): EmitFlags | undefined {

const emitNode = node.emitNode;

return emitNode && emitNode.flags;

}

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

// 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 && !(isNumericLiteral(node) && node.numericLiteralFlags & TokenFlags.ContainsSeparator)) {

return getSourceTextOfNodeFromSourceFile(sourceFile, node);

}

const escapeText = getEmitFlags(node) & EmitFlags.NoAsciiEscaping ? escapeString : escapeNonAsciiString;

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

// or a (possibly escaped) quoted form of the original text if it's string-like.

switch (node.kind) {

case SyntaxKind.StringLiteral:

if ((<StringLiteral>node).singleQuote) {

return "'" + escapeText(node.text, CharacterCodes.singleQuote) + "'";

}

else {

return '"' + escapeText(node.text, CharacterCodes.doubleQuote) + '"';

}

case SyntaxKind.NoSubstitutionTemplateLiteral:

return "`" + escapeText(node.text, CharacterCodes.backtick) + "`";

case SyntaxKind.TemplateHead:

// tslint:disable-next-line no-invalid-template-strings

return "`" + escapeText(node.text, CharacterCodes.backtick) + "${";

case SyntaxKind.TemplateMiddle:

// tslint:disable-next-line no-invalid-template-strings

return "}" + escapeText(node.text, CharacterCodes.backtick) + "${";

case SyntaxKind.TemplateTail:

return "}" + escapeText(node.text, CharacterCodes.backtick) + "`";

case SyntaxKind.NumericLiteral:

case SyntaxKind.RegularExpressionLiteral:

return node.text;

}

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

}

export function getTextOfConstantValue(value: string | number) {

return isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value;

}

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

export function escapeLeadingUnderscores(identifier: string): __String {

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

}

/**

* @deprecated Use `id.escapedText` to get the escaped text of an Identifier.

* @param identifier The identifier to escape

*/

export function escapeIdentifier(identifier: string): string {

return 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 ||

isCatchClauseVariableDeclarationOrBindingElement(declaration);

}

export function isCatchClauseVariableDeclarationOrBindingElement(declaration: Declaration) {

const node = getRootDeclaration(declaration);

return node.kind === SyntaxKind.VariableDeclaration && node.parent.kind === SyntaxKind.CatchClause;

}

export function isAmbientModule(node: Node): boolean {

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

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

}

export function isModuleWithStringLiteralName(node: Node): node is ModuleDeclaration {

return isModuleDeclaration(node) && node.name.kind === SyntaxKind.StringLiteral;

}

export function isNonGlobalAmbientModule(node: Node): node is ModuleDeclaration & { name: StringLiteral } {

return isModuleDeclaration(node) && isStringLiteral(node.name);

}

/** Given a symbol for a module, checks that it is a shorthand ambient module. */

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 && 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 isEffectiveExternalModule(node: SourceFile, compilerOptions: CompilerOptions) {

return isExternalModule(node) || compilerOptions.isolatedModules || ((getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS) && !!node.commonJsModuleIndicator);

}

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;

}

export function isDeclarationWithTypeParameters(node: Node): node is DeclarationWithTypeParameters;

export function isDeclarationWithTypeParameters(node: DeclarationWithTypeParameters): node is DeclarationWithTypeParameters {

switch (node.kind) {

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.MethodSignature:

case SyntaxKind.IndexSignature:

case SyntaxKind.FunctionType:

case SyntaxKind.ConstructorType:

case SyntaxKind.JSDocFunctionType:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.JSDocTemplateTag:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction:

return true;

default:

assertTypeIsNever(node);

return false;

}

}

export function isAnyImportSyntax(node: Node): node is AnyImportSyntax {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

return true;

default:

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;

}

}

// 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 | QualifiedName) {

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

}

export function getNameFromIndexInfo(info: IndexInfo): string | undefined {

return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined;

}

export function getTextOfPropertyName(name: PropertyName): __String {

switch (name.kind) {

case SyntaxKind.Identifier:

return (<Identifier>name).escapedText;

case SyntaxKind.StringLiteral:

case SyntaxKind.NumericLiteral:

return escapeLeadingUnderscores((<LiteralExpression>name).text);

case SyntaxKind.ComputedPropertyName:

if (isStringOrNumericLiteral((<ComputedPropertyName>name).expression)) {

return escapeLeadingUnderscores((<LiteralExpression>(<ComputedPropertyName>name).expression).text);

}

}

return undefined;

}

export function entityNameToString(name: EntityNameOrEntityNameExpression): string {

switch (name.kind) {

case SyntaxKind.Identifier:

return getFullWidth(name) === 0 ? idText(name) : getTextOfNode(name);

case SyntaxKind.QualifiedName:

return entityNameToString(name.left) + "." + entityNameToString(name.right);

case SyntaxKind.PropertyAccessExpression:

return entityNameToString(name.expression) + "." + entityNameToString(name.name);

}

}

export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {

const sourceFile = getSourceFileOfNode(node);

return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);

}

export function createDiagnosticForNodeInSourceFile(sourceFile: SourceFile, node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {

const span = getErrorSpanForNode(sourceFile, node);

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

}

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:

const 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 = (<NamedDeclaration>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 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 isSuperCall(n: Node): n is SuperCall {

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

}

export function isImportCall(n: Node): n is ImportCall {

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

}

export function isPrologueDirective(node: Node): node is PrologueDirective {

return node.kind === SyntaxKind.ExpressionStatement

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

}

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

return node.kind !== SyntaxKind.JsxText ? getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : undefined;

}

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

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

node.kind === SyntaxKind.TypeParameter ||

node.kind === SyntaxKind.FunctionExpression ||

node.kind === SyntaxKind.ArrowFunction ||

node.kind === SyntaxKind.ParenthesizedExpression) ?

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

getLeadingCommentRanges(text, node.pos);

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

return filter(commentRanges, comment =>

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

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

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

}

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

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

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

const defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/;

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'.");

// falls through

case SyntaxKind.QualifiedName:

case SyntaxKind.PropertyAccessExpression:

case SyntaxKind.ThisKeyword:

const 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 and A.B.C are type nodes.

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 === (parent as HasType).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;

}

export function isChildOfNodeWithKind(node: Node, kind: SyntaxKind): boolean {

while (node) {

if (node.kind === kind) {

return true;

}

node = node.parent;

}

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

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

if (operand) {

traverse(operand);

}

return;

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

}

}

}

}

/**

* Gets the most likely element type for a TypeNode. This is not an exhaustive test

* as it assumes a rest argument can only be an array type (either T[], or Array<T>).

*

* @param node The type node.

*/

export function getRestParameterElementType(node: TypeNode) {

if (node && node.kind === SyntaxKind.ArrayType) {

return (<ArrayTypeNode>node).elementType;

}

else if (node && node.kind === SyntaxKind.TypeReference) {

return singleOrUndefined((<TypeReferenceNode>node).typeArguments);

}

else {

return undefined;

}

}

export function getMembersOfDeclaration(node: Declaration): NodeArray<ClassElement | TypeElement | ObjectLiteralElement> | undefined {

switch (node.kind) {

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

case SyntaxKind.TypeLiteral:

return (<ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode>node).members;

case SyntaxKind.ObjectLiteralExpression:

return (<ObjectLiteralExpression>node).properties;

}

}

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 isVariableDeclarationInVariableStatement(node: VariableDeclaration) {

return node.parent.kind === SyntaxKind.VariableDeclarationList

&& node.parent.parent.kind === SyntaxKind.VariableStatement;

}

export function isValidESSymbolDeclaration(node: Node) {

return isVariableDeclaration(node) ? isConst(node) && isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :

isPropertyDeclaration(node) ? hasReadonlyModifier(node) && hasStaticModifier(node) :

isPropertySignature(node) && hasReadonlyModifier(node);

}

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 unwrapInnermostStatementOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) {

while (true) {

if (beforeUnwrapLabelCallback) {

beforeUnwrapLabelCallback(node);

}

if (node.statement.kind !== SyntaxKind.LabeledStatement) {

return node.statement;

}

node = <LabeledStatement>node.statement;

}

}

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 isObjectLiteralOrClassExpressionMethod(node: Node): node is MethodDeclaration {

return node.kind === SyntaxKind.MethodDeclaration &&

(node.parent.kind === SyntaxKind.ObjectLiteralExpression ||

node.parent.kind === SyntaxKind.ClassExpression);

}

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

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

}

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