/** Non-internal stuff goes here */

namespace ts {

export function isExternalModuleNameRelative(moduleName: string): boolean {

// TypeScript 1.0 spec (April 2014): 11.2.1

// An external module name is "relative" if the first term is "." or "..".

// Update: We also consider a path like `C:\foo.ts` "relative" because we do not search for it in `node_modules` or treat it as an ambient module.

return pathIsRelative(moduleName) || isRootedDiskPath(moduleName);

}

export function sortAndDeduplicateDiagnostics<T extends Diagnostic>(diagnostics: ReadonlyArray<T>): T[] {

return sortAndDeduplicate<T>(diagnostics, compareDiagnostics);

}

}

/* @internal */

namespace ts {

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

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

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

export const emptyUnderscoreEscapedMap: ReadonlyUnderscoreEscapedMap<never> = emptyMap as ReadonlyUnderscoreEscapedMap<never>;

export const externalHelpersModuleNameText = "tslib";

export const defaultMaximumTruncationLength = 160;

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

const declarations = symbol.declarations;

if (declarations) {

for (const declaration of declarations) {

if (declaration.kind === kind) {

return declaration as T;

}

}

}

return undefined;

}

/** Create a new escaped identifier map. */

export function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T> {

return new MapCtr<T>() as UnderscoreEscapedMap<T>;

}

export function hasEntries(map: ReadonlyUnderscoreEscapedMap<any> | undefined): map is ReadonlyUnderscoreEscapedMap<any> {

return !!map && !!map.size;

}

export function createSymbolTable(symbols?: ReadonlyArray<Symbol>): SymbolTable {

const result = createMap<Symbol>() as SymbolTable;

if (symbols) {

for (const symbol of symbols) {

result.set(symbol.escapedName, symbol);

}

}

return result;

}

const stringWriter = createSingleLineStringWriter();

function createSingleLineStringWriter(): EmitTextWriter {

let str = "";

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

return {

getText: () => str,

write: writeText,

rawWrite: writeText,

writeTextOfNode: writeText,

writeKeyword: writeText,

writeOperator: writeText,

writePunctuation: writeText,

writeSpace: writeText,

writeStringLiteral: writeText,

writeLiteral: writeText,

writeParameter: writeText,

writeProperty: writeText,

writeSymbol: writeText,

getTextPos: () => str.length,

getLine: () => 0,

getColumn: () => 0,

getIndent: () => 0,

isAtStartOfLine: () => false,

// 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 toPath(fileName: string, basePath: string | undefined, getCanonicalFileName: (path: string) => string): Path {

const nonCanonicalizedPath = isRootedDiskPath(fileName)

? normalizePath(fileName)

: getNormalizedAbsolutePath(fileName, basePath);

return <Path>getCanonicalFileName(nonCanonicalizedPath);

}

export function changesAffectModuleResolution(oldOptions: CompilerOptions, newOptions: CompilerOptions): boolean {

return !oldOptions ||

(oldOptions.module !== newOptions.module) ||

(oldOptions.moduleResolution !== newOptions.moduleResolution) ||

(oldOptions.noResolve !== newOptions.noResolve) ||

(oldOptions.target !== newOptions.target) ||

(oldOptions.noLib !== newOptions.noLib) ||

(oldOptions.jsx !== newOptions.jsx) ||

(oldOptions.allowJs !== newOptions.allowJs) ||

(oldOptions.rootDir !== newOptions.rootDir) ||

(oldOptions.configFilePath !== newOptions.configFilePath) ||

(oldOptions.baseUrl !== newOptions.baseUrl) ||

(oldOptions.maxNodeModuleJsDepth !== newOptions.maxNodeModuleJsDepth) ||

!arrayIsEqualTo(oldOptions.lib, newOptions.lib) ||

!arrayIsEqualTo(oldOptions.typeRoots, newOptions.typeRoots) ||

!arrayIsEqualTo(oldOptions.rootDirs, newOptions.rootDirs) ||

!equalOwnProperties(oldOptions.paths, newOptions.paths);

}

/**

* Iterates through the parent chain of a node and performs the callback on each parent until the callback

* returns a truthy value, then returns that value.

* If no such value is found, it applies the callback until the parent pointer is undefined or the callback returns "quit"

* At that point findAncestor returns undefined.

*/

export function findAncestor<T extends Node>(node: Node | undefined, callback: (element: Node) => element is T): T | undefined;

export function findAncestor(node: Node | undefined, callback: (element: Node) => boolean | "quit"): Node | undefined;

export function findAncestor(node: Node, callback: (element: Node) => boolean | "quit"): Node | undefined {

while (node) {

const result = callback(node);

if (result === "quit") {

return undefined;

}

else if (result) {

return node;

}

node = node.parent;

}

return undefined;

}

export function forEachAncestor<T>(node: Node, callback: (n: Node) => T | undefined | "quit"): T | undefined {

while (true) {

const res = callback(node);

if (res === "quit") return undefined;

if (res !== undefined) return res;

if (isSourceFile(node)) return undefined;

node = node.parent;

}

}

/**

* Calls `callback` for each entry in the map, returning the first truthy result.

* Use `map.forEach` instead for normal iteration.

*/

export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T>, callback: (value: T, key: __String) => U | undefined): U | undefined;

export function forEachEntry<T, U>(map: ReadonlyMap<T>, callback: (value: T, key: string) => U | undefined): U | undefined;

export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T> | ReadonlyMap<T>, callback: (value: T, key: (string & __String)) => U | undefined): U | undefined {

const iterator = map.entries();

for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {

const [key, value] = pair;

const result = callback(value, key as (string & __String));

if (result) {

return result;

}

}

return undefined;

}

/** `forEachEntry` for just keys. */

export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}>, callback: (key: __String) => T | undefined): T | undefined;

export function forEachKey<T>(map: ReadonlyMap<{}>, callback: (key: string) => T | undefined): T | undefined;

export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}> | ReadonlyMap<{}>, callback: (key: string & __String) => T | undefined): T | undefined {

const iterator = map.keys();

for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {

const result = callback(key as string & __String);

if (result) {

return result;

}

}

return undefined;

}

/** Copy entries from `source` to `target`. */

export function copyEntries<T>(source: ReadonlyUnderscoreEscapedMap<T>, target: UnderscoreEscapedMap<T>): void;

export function copyEntries<T>(source: ReadonlyMap<T>, target: Map<T>): void;

export function copyEntries<T, U extends UnderscoreEscapedMap<T> | Map<T>>(source: U, target: U): void {

(source as Map<T>).forEach((value, key) => {

(target as Map<T>).set(key, value);

});

}

/**

* Creates a set from the elements of an array.

*

* @param array the array of input elements.

*/

export function arrayToSet(array: ReadonlyArray<string>): Map<true>;

export function arrayToSet<T>(array: ReadonlyArray<T>, makeKey: (value: T) => string | undefined): Map<true>;

export function arrayToSet<T>(array: ReadonlyArray<T>, makeKey: (value: T) => __String | undefined): UnderscoreEscapedMap<true>;

export function arrayToSet(array: ReadonlyArray<any>, makeKey?: (value: any) => string | __String | undefined): Map<true> | UnderscoreEscapedMap<true> {

return arrayToMap<any, true>(array, makeKey || (s => s), () => true);

}

export function cloneMap(map: SymbolTable): SymbolTable;

export function cloneMap<T>(map: ReadonlyMap<T>): Map<T>;

export function cloneMap<T>(map: ReadonlyUnderscoreEscapedMap<T>): UnderscoreEscapedMap<T>;

export function cloneMap<T>(map: ReadonlyMap<T> | ReadonlyUnderscoreEscapedMap<T> | SymbolTable): Map<T> | UnderscoreEscapedMap<T> | SymbolTable {

const clone = createMap<T>();

copyEntries(map as Map<T>, clone);

return clone;

}

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

const oldString = stringWriter.getText();

try {

action(stringWriter);

return stringWriter.getText();

}

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 packageIdToString({ name, subModuleName, version }: PackageId): string {

const fullName = subModuleName ? `${name}/${subModuleName}` : name;

return `${fullName}@${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> | undefined,

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;

export function getSourceFileOfNode(node: Node | undefined): SourceFile | undefined;

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 a value indicating whether a name is unique globally or within the current file.

* Note: This does not consider whether a name appears as a free identifier or not, so at the expression `x.y` this includes both `x` and `y`.

*/

export function isFileLevelUniqueName(sourceFile: SourceFile, name: string, hasGlobalName?: PrintHandlers["hasGlobalName"]): boolean {

return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name);

}

// 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 | undefined): boolean {

if (node === undefined) {

return true;

}

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

}

export function nodeIsPresent(node: Node | undefined): boolean {

return !nodeIsMissing(node);

}

/**

* Prepends statements to an array while taking care of prologue directives.

*/

export function addStatementsAfterPrologue<T extends Statement>(to: T[], from: ReadonlyArray<T> | undefined): T[] {

if (from === undefined || from.length === 0) return to;

let statementIndex = 0;

// skip all prologue directives to insert at the correct position

for (; statementIndex < to.length; ++statementIndex) {

if (!isPrologueDirective(to[statementIndex])) {

break;

}

}

to.splice(statementIndex, 0, ...from);

return to;

}

/**

* 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, start: number) {

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

text.charCodeAt(start + 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 {

return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia);

}

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

if (nodeIsMissing(node)) {

return "";

}

return sourceText.substring(includeTrivia ? node.pos : 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 {

const emitNode = node.emitNode;

return emitNode && emitNode.flags || 0;

}

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;

}

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

}

export function getTextOfConstantValue(value: string | number) {

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

}

// 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): node is AmbientModuleDeclaration {

return isModuleDeclaration(node) && (node.name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(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);

}

/**

* An effective module (namespace) declaration is either

* 1. An actual declaration: namespace X { ... }

* 2. A Javascript declaration, which is:

* An identifier in a nested property access expression: Y in `X.Y.Z = { ... }`

*/

export function isEffectiveModuleDeclaration(node: Node) {

return isModuleDeclaration(node) || isIdentifier(node);

}

/** 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): node is AmbientModuleDeclaration {

return isAmbientModule(node) && isModuleAugmentationExternal(node);

}

export function isModuleAugmentationExternal(node: AmbientModuleDeclaration) {

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

switch (node.parent.kind) {

case SyntaxKind.SourceFile:

return isExternalModule(node.parent);

case SyntaxKind.ModuleBlock:

return isAmbientModule(node.parent.parent) && isSourceFile(node.parent.parent.parent) && !isExternalModule(node.parent.parent.parent);

}

return false;

}

export function getNonAugmentationDeclaration(symbol: Symbol) {

return find(symbol.declarations, d => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));

}

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): boolean {

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 !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.JSDocCallbackTag:

case SyntaxKind.JSDocTypedefTag:

case SyntaxKind.JSDocSignature:

return true;

default:

assertType<DeclarationWithTypeParameterChildren>(node);

return isDeclarationWithTypeParameterChildren(node);

}

}

export function isDeclarationWithTypeParameterChildren(node: Node): node is DeclarationWithTypeParameterChildren;

export function isDeclarationWithTypeParameterChildren(node: DeclarationWithTypeParameterChildren): node is DeclarationWithTypeParameterChildren {

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:

assertType<never>(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;

}

}

export function isLateVisibilityPaintedStatement(node: Node): node is LateVisibilityPaintedStatement {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.VariableStatement:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.EnumDeclaration:

return true;

default:

return false;

}

}

export function isAnyImportOrReExport(node: Node): node is AnyImportOrReExport {

return isAnyImportSyntax(node) || isExportDeclaration(node);

}

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

return findAncestor(node.parent, current => isBlockScope(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 | undefined) {

return !name || 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 name.escapedText;

case SyntaxKind.StringLiteral:

case SyntaxKind.NumericLiteral:

return escapeLeadingUnderscores(name.text);

case SyntaxKind.ComputedPropertyName:

return isStringOrNumericLiteralLike(name.expression) ? escapeLeadingUnderscores(name.expression.text) : undefined!; // TODO: GH#18217 Almost all uses of this assume the result to be defined!

default:

return Debug.assertNever(name);

}

}

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

default:

throw Debug.assertNever(name);

}

}

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

const sourceFile = getSourceFileOfNode(node);

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

}

export function createDiagnosticForNodeArray(sourceFile: SourceFile, nodes: NodeArray<Node>, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): DiagnosticWithLocation {

const start = skipTrivia(sourceFile.text, nodes.pos);

return createFileDiagnostic(sourceFile, start, nodes.end - start, 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): DiagnosticWithLocation {

const span = getErrorSpanForNode(sourceFile, node);

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

}

export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, relatedInformation?: DiagnosticRelatedInformation[]): DiagnosticWithLocation {

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,

relatedInformation

};

}

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 | undefined = 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:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

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 isMissing = nodeIsMissing(errorNode);

const pos = isMissing

? errorNode.pos

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

// These asserts should all be satisfied for a properly constructed `errorNode`.

if (isMissing) {

Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");

Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");

}

else {

Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");

Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");

}

return createTextSpanFromBounds(pos, errorNode.end);

}

export function isExternalOrCommonJsModule(file: SourceFile): boolean {

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

}

export function isJsonSourceFile(file: SourceFile): file is JsonSourceFile {

return file.scriptKind === ScriptKind.JSON;

}

export function isEnumConst(node: EnumDeclaration): boolean {

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

}

export function isVarConst(node: VariableDeclaration | VariableDeclarationList): boolean {

return !!(getCombinedNodeFlags(node) & NodeFlags.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 isLiteralImportTypeNode(n: Node): n is LiteralImportTypeNode {

return isImportTypeNode(n) && isLiteralTypeNode(n.argument) && isStringLiteral(n.argument.literal);

}

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.UnknownKeyword:

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

case SyntaxKind.TypeParameter:

return node.parent.kind === SyntaxKind.MappedType || node.parent.kind === SyntaxKind.InferType;

// 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: