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: readonly T[]): SortedReadonlyArray<T> {

return sortAndDeduplicate<T>(diagnostics, compareDiagnostics);

}

export function getDefaultLibFileName(options: CompilerOptions): string {

switch (getEmitScriptTarget(options)) {

case ScriptTarget.ESNext:

return "lib.esnext.full.d.ts";

case ScriptTarget.ES2022:

return "lib.es2022.full.d.ts";

case ScriptTarget.ES2021:

return "lib.es2021.full.d.ts";

case ScriptTarget.ES2020:

return "lib.es2020.full.d.ts";

case ScriptTarget.ES2019:

return "lib.es2019.full.d.ts";

case ScriptTarget.ES2018:

return "lib.es2018.full.d.ts";

case ScriptTarget.ES2017:

return "lib.es2017.full.d.ts";

case ScriptTarget.ES2016:

return "lib.es2016.full.d.ts";

case ScriptTarget.ES2015:

return "lib.es6.d.ts"; // We don't use lib.es2015.full.d.ts due to breaking change.

default:

return "lib.d.ts";

}

}

export function textSpanEnd(span: TextSpan) {

return span.start + span.length;

}

export function textSpanIsEmpty(span: TextSpan) {

return span.length === 0;

}

export function textSpanContainsPosition(span: TextSpan, position: number) {

return position >= span.start && position < textSpanEnd(span);

}

/* @internal */

export function textRangeContainsPositionInclusive(span: TextRange, position: number): boolean {

return position >= span.pos && position <= span.end;

}

// Returns true if 'span' contains 'other'.

export function textSpanContainsTextSpan(span: TextSpan, other: TextSpan) {

return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span);

}

export function textSpanOverlapsWith(span: TextSpan, other: TextSpan) {

return textSpanOverlap(span, other) !== undefined;

}

export function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan | undefined {

const overlap = textSpanIntersection(span1, span2);

return overlap && overlap.length === 0 ? undefined : overlap;

}

export function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan) {

return decodedTextSpanIntersectsWith(span.start, span.length, other.start, other.length);

}

export function textSpanIntersectsWith(span: TextSpan, start: number, length: number) {

return decodedTextSpanIntersectsWith(span.start, span.length, start, length);

}

export function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number) {

const end1 = start1 + length1;

const end2 = start2 + length2;

return start2 <= end1 && end2 >= start1;

}

export function textSpanIntersectsWithPosition(span: TextSpan, position: number) {

return position <= textSpanEnd(span) && position >= span.start;

}

export function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan | undefined {

const start = Math.max(span1.start, span2.start);

const end = Math.min(textSpanEnd(span1), textSpanEnd(span2));

return start <= end ? createTextSpanFromBounds(start, end) : undefined;

}

export function createTextSpan(start: number, length: number): TextSpan {

if (start < 0) {

throw new Error("start < 0");

}

if (length < 0) {

throw new Error("length < 0");

}

return { start, length };

}

export function createTextSpanFromBounds(start: number, end: number) {

return createTextSpan(start, end - start);

}

export function textChangeRangeNewSpan(range: TextChangeRange) {

return createTextSpan(range.span.start, range.newLength);

}

export function textChangeRangeIsUnchanged(range: TextChangeRange) {

return textSpanIsEmpty(range.span) && range.newLength === 0;

}

export function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange {

if (newLength < 0) {

throw new Error("newLength < 0");

}

return { span, newLength };

}

export let unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); // eslint-disable-line prefer-const

/**

* Called to merge all the changes that occurred across several versions of a script snapshot

* into a single change. i.e. if a user keeps making successive edits to a script we will

* have a text change from V1 to V2, V2 to V3, ..., Vn.

*

* This function will then merge those changes into a single change range valid between V1 and

* Vn.

*/

export function collapseTextChangeRangesAcrossMultipleVersions(changes: readonly TextChangeRange[]): TextChangeRange {

if (changes.length === 0) {

return unchangedTextChangeRange;

}

if (changes.length === 1) {

return changes[0];

}

// We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }

// as it makes things much easier to reason about.

const change0 = changes[0];

let oldStartN = change0.span.start;

let oldEndN = textSpanEnd(change0.span);

let newEndN = oldStartN + change0.newLength;

for (let i = 1; i < changes.length; i++) {

const nextChange = changes[i];

// Consider the following case:

// i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting

// at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }.

// i.e. the span starting at 30 with length 30 is increased to length 40.

//

// 0 10 20 30 40 50 60 70 80 90 100

// -------------------------------------------------------------------------------------------------------

// | /

// | /----

// T1 | /----

// | /----

// | /----

// -------------------------------------------------------------------------------------------------------

// | \

// | \

// T2 | \

// | \

// | \

// -------------------------------------------------------------------------------------------------------

//

// Merging these turns out to not be too difficult. First, determining the new start of the change is trivial

// it's just the min of the old and new starts. i.e.:

//

// 0 10 20 30 40 50 60 70 80 90 100

// ------------------------------------------------------------*------------------------------------------

// | /

// | /----

// T1 | /----

// | /----

// | /----

// ----------------------------------------$-------------------$------------------------------------------

// . | \

// . | \

// T2 . | \

// . | \

// . | \

// ----------------------------------------------------------------------*--------------------------------

//

// (Note the dots represent the newly inferred start.

// Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the

// absolute positions at the asterisks, and the relative change between the dollar signs. Basically, we see

// which if the two $'s precedes the other, and we move that one forward until they line up. in this case that

// means:

//

// 0 10 20 30 40 50 60 70 80 90 100

// --------------------------------------------------------------------------------*----------------------

// | /

// | /----

// T1 | /----

// | /----

// | /----

// ------------------------------------------------------------$------------------------------------------

// . | \

// . | \

// T2 . | \

// . | \

// . | \

// ----------------------------------------------------------------------*--------------------------------

//

// In other words (in this case), we're recognizing that the second edit happened after where the first edit

// ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started

// that's the same as if we started at char 80 instead of 60.

//

// As it so happens, the same logic applies if the second edit precedes the first edit. In that case rather

// than pushing the first edit forward to match the second, we'll push the second edit forward to match the

// first.

//

// In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange

// semantics: { { start: 10, length: 70 }, newLength: 60 }

//

// The math then works out as follows.

// If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the

// final result like so:

//

// {

// oldStart3: Min(oldStart1, oldStart2),

// oldEnd3: Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)),

// newEnd3: Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))

// }

const oldStart1 = oldStartN;

const oldEnd1 = oldEndN;

const newEnd1 = newEndN;

const oldStart2 = nextChange.span.start;

const oldEnd2 = textSpanEnd(nextChange.span);

const newEnd2 = oldStart2 + nextChange.newLength;

oldStartN = Math.min(oldStart1, oldStart2);

oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));

newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));

}

return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength*/ newEndN - oldStartN);

}

export function getTypeParameterOwner(d: Declaration): Declaration | undefined {

if (d && d.kind === SyntaxKind.TypeParameter) {

for (let current: Node = d; current; current = current.parent) {

if (isFunctionLike(current) || isClassLike(current) || current.kind === SyntaxKind.InterfaceDeclaration) {

return current as Declaration;

}

}

}

}

export type ParameterPropertyDeclaration = ParameterDeclaration & { parent: ConstructorDeclaration, name: Identifier };

export function isParameterPropertyDeclaration(node: Node, parent: Node): node is ParameterPropertyDeclaration {

return hasSyntacticModifier(node, ModifierFlags.ParameterPropertyModifier) && parent.kind === SyntaxKind.Constructor;

}

export function isEmptyBindingPattern(node: BindingName): node is BindingPattern {

if (isBindingPattern(node)) {

return every(node.elements, isEmptyBindingElement);

}

return false;

}

export function isEmptyBindingElement(node: BindingElement): boolean {

if (isOmittedExpression(node)) {

return true;

}

return isEmptyBindingPattern(node.name);

}

export function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration {

let node = binding.parent;

while (isBindingElement(node.parent)) {

node = node.parent.parent;

}

return node.parent;

}

function getCombinedFlags(node: Node, getFlags: (n: Node) => number): number {

if (isBindingElement(node)) {

node = walkUpBindingElementsAndPatterns(node);

}

let flags = getFlags(node);

if (node.kind === SyntaxKind.VariableDeclaration) {

node = node.parent;

}

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

flags |= getFlags(node);

node = node.parent;

}

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

flags |= getFlags(node);

}

return flags;

}

export function getCombinedModifierFlags(node: Declaration): ModifierFlags {

return getCombinedFlags(node, getEffectiveModifierFlags);

}

/* @internal */

export function getCombinedNodeFlagsAlwaysIncludeJSDoc(node: Declaration): ModifierFlags {

return getCombinedFlags(node, getEffectiveModifierFlagsAlwaysIncludeJSDoc);

}

// Returns the node flags for this node and all relevant parent nodes. This is done so that

// nodes like variable declarations and binding elements can returned a view of their flags

// that includes the modifiers from their container. i.e. flags like export/declare aren't

// stored on the variable declaration directly, but on the containing variable statement

// (if it has one). Similarly, flags for let/const are stored on the variable declaration

// list. By calling this function, all those flags are combined so that the client can treat

// the node as if it actually had those flags.

export function getCombinedNodeFlags(node: Node): NodeFlags {

return getCombinedFlags(node, n => n.flags);

}

/* @internal */

export const supportedLocaleDirectories = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"];

/**

* Checks to see if the locale is in the appropriate format,

* and if it is, attempts to set the appropriate language.

*/

export function validateLocaleAndSetLanguage(

locale: string,

sys: { getExecutingFilePath(): string, resolvePath(path: string): string, fileExists(fileName: string): boolean, readFile(fileName: string): string | undefined },

errors?: Push<Diagnostic>) {

const lowerCaseLocale = locale.toLowerCase();

const matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(lowerCaseLocale);

if (!matchResult) {

if (errors) {

errors.push(createCompilerDiagnostic(Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp"));

}

return;

}

const language = matchResult[1];

const territory = matchResult[3];

// First try the entire locale, then fall back to just language if that's all we have.

// Either ways do not fail, and fallback to the English diagnostic strings.

if (contains(supportedLocaleDirectories, lowerCaseLocale) && !trySetLanguageAndTerritory(language, territory, errors)) {

trySetLanguageAndTerritory(language, /*territory*/ undefined, errors);

}

// Set the UI locale for string collation

setUILocale(locale);

function trySetLanguageAndTerritory(language: string, territory: string | undefined, errors?: Push<Diagnostic>): boolean {

const compilerFilePath = normalizePath(sys.getExecutingFilePath());

const containingDirectoryPath = getDirectoryPath(compilerFilePath);

let filePath = combinePaths(containingDirectoryPath, language);

if (territory) {

filePath = filePath + "-" + territory;

}

filePath = sys.resolvePath(combinePaths(filePath, "diagnosticMessages.generated.json"));

if (!sys.fileExists(filePath)) {

return false;

}

// TODO: Add codePage support for readFile?

let fileContents: string | undefined = "";

try {

fileContents = sys.readFile(filePath);

}

catch (e) {

if (errors) {

errors.push(createCompilerDiagnostic(Diagnostics.Unable_to_open_file_0, filePath));

}

return false;

}

try {

// this is a global mutation (or live binding update)!

setLocalizedDiagnosticMessages(JSON.parse(fileContents!));

}

catch {

if (errors) {

errors.push(createCompilerDiagnostic(Diagnostics.Corrupted_locale_file_0, filePath));

}

return false;

}

return true;

}

}

export function getOriginalNode(node: Node): Node;

export function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;

export function getOriginalNode(node: Node | undefined): Node | undefined;

export function getOriginalNode<T extends Node>(node: Node | undefined, nodeTest: (node: Node | undefined) => node is T): T | undefined;

export function getOriginalNode(node: Node | undefined, nodeTest?: (node: Node | undefined) => boolean): Node | undefined {

if (node) {

while (node.original !== undefined) {

node = node.original;

}

}

return !nodeTest || nodeTest(node) ? node : undefined;

}

/**

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

}

/**

* Gets a value indicating whether a node originated in the parse tree.

*

* @param node The node to test.

*/

export function isParseTreeNode(node: Node): boolean {

return (node.flags & NodeFlags.Synthesized) === 0;

}

/**

* Gets the original parse tree node for a node.

*

* @param node The original node.

* @returns The original parse tree node if found; otherwise, undefined.

*/

export function getParseTreeNode(node: Node | undefined): Node | undefined;

/**

* Gets the original parse tree node for a node.

*

* @param node The original node.

* @param nodeTest A callback used to ensure the correct type of parse tree node is returned.

* @returns The original parse tree node if found; otherwise, undefined.

*/

export function getParseTreeNode<T extends Node>(node: T | undefined, nodeTest?: (node: Node) => node is T): T | undefined;

export function getParseTreeNode(node: Node | undefined, nodeTest?: (node: Node) => boolean): Node | undefined {

if (node === undefined || isParseTreeNode(node)) {

return node;

}

node = node.original;

while (node) {

if (isParseTreeNode(node)) {

return !nodeTest || nodeTest(node) ? node : undefined;

}

node = node.original;

}

}

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

}

/**

* Remove extra underscore from escaped identifier text content.

*

* @param identifier The escaped identifier text.

* @returns The unescaped identifier text.

*/

export function unescapeLeadingUnderscores(identifier: __String): string {

const id = identifier as string;

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

}

export function idText(identifierOrPrivateName: Identifier | PrivateIdentifier): string {

return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText);

}

export function symbolName(symbol: Symbol): string {

if (symbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) {

return idText(symbol.valueDeclaration.name);

}

return unescapeLeadingUnderscores(symbol.escapedName);

}

/**

* A JSDocTypedef tag has an _optional_ name field - if a name is not directly present, we should

* attempt to draw the name from the node the declaration is on (as that declaration is what its' symbol

* will be merged with)

*/

function nameForNamelessJSDocTypedef(declaration: JSDocTypedefTag | JSDocEnumTag): Identifier | PrivateIdentifier | undefined {

const hostNode = declaration.parent.parent;

if (!hostNode) {

return undefined;

}

// Covers classes, functions - any named declaration host node

if (isDeclaration(hostNode)) {

return getDeclarationIdentifier(hostNode);

}

// Covers remaining cases (returning undefined if none match).

switch (hostNode.kind) {

case SyntaxKind.VariableStatement:

if (hostNode.declarationList && hostNode.declarationList.declarations[0]) {

return getDeclarationIdentifier(hostNode.declarationList.declarations[0]);

}

break;

case SyntaxKind.ExpressionStatement:

let expr = hostNode.expression;

if (expr.kind === SyntaxKind.BinaryExpression && (expr as BinaryExpression).operatorToken.kind === SyntaxKind.EqualsToken) {

expr = (expr as BinaryExpression).left;

}

switch (expr.kind) {

case SyntaxKind.PropertyAccessExpression:

return (expr as PropertyAccessExpression).name;

case SyntaxKind.ElementAccessExpression:

const arg = (expr as ElementAccessExpression).argumentExpression;

if (isIdentifier(arg)) {

return arg;

}

}

break;

case SyntaxKind.ParenthesizedExpression: {

return getDeclarationIdentifier(hostNode.expression);

}

case SyntaxKind.LabeledStatement: {

if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) {

return getDeclarationIdentifier(hostNode.statement);

}

break;

}

}

}

function getDeclarationIdentifier(node: Declaration | Expression): Identifier | undefined {

const name = getNameOfDeclaration(node);

return name && isIdentifier(name) ? name : undefined;

}

/** @internal */

export function nodeHasName(statement: Node, name: Identifier) {

if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name as Identifier) === idText(name)) {

return true;

}

if (isVariableStatement(statement) && some(statement.declarationList.declarations, d => nodeHasName(d, name))) {

return true;

}

return false;

}

export function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateIdentifier | undefined {

return declaration.name || nameForNamelessJSDocTypedef(declaration);

}

/** @internal */

export function isNamedDeclaration(node: Node): node is NamedDeclaration & { name: DeclarationName } {

return !!(node as NamedDeclaration).name; // A 'name' property should always be a DeclarationName.

}

/** @internal */

export function getNonAssignedNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined {

switch (declaration.kind) {

case SyntaxKind.Identifier:

return declaration as Identifier;

case SyntaxKind.JSDocPropertyTag:

case SyntaxKind.JSDocParameterTag: {

const { name } = declaration as JSDocPropertyLikeTag;

if (name.kind === SyntaxKind.QualifiedName) {

return name.right;

}

break;

}

case SyntaxKind.CallExpression:

case SyntaxKind.BinaryExpression: {

const expr = declaration as BinaryExpression | CallExpression;

switch (getAssignmentDeclarationKind(expr)) {

case AssignmentDeclarationKind.ExportsProperty:

case AssignmentDeclarationKind.ThisProperty:

case AssignmentDeclarationKind.Property:

case AssignmentDeclarationKind.PrototypeProperty:

return getElementOrPropertyAccessArgumentExpressionOrName((expr as BinaryExpression).left as AccessExpression);

case AssignmentDeclarationKind.ObjectDefinePropertyValue:

case AssignmentDeclarationKind.ObjectDefinePropertyExports:

case AssignmentDeclarationKind.ObjectDefinePrototypeProperty:

return (expr as BindableObjectDefinePropertyCall).arguments[1];

default:

return undefined;

}

}

case SyntaxKind.JSDocTypedefTag:

return getNameOfJSDocTypedef(declaration as JSDocTypedefTag);

case SyntaxKind.JSDocEnumTag:

return nameForNamelessJSDocTypedef(declaration as JSDocEnumTag);

case SyntaxKind.ExportAssignment: {

const { expression } = declaration as ExportAssignment;

return isIdentifier(expression) ? expression : undefined;

}

case SyntaxKind.ElementAccessExpression:

const expr = declaration as ElementAccessExpression;

if (isBindableStaticElementAccessExpression(expr)) {

return expr.argumentExpression;

}

}

return (declaration as NamedDeclaration).name;

}

export function getNameOfDeclaration(declaration: Declaration | Expression | undefined): DeclarationName | undefined {

if (declaration === undefined) return undefined;

return getNonAssignedNameOfDeclaration(declaration) ||

(isFunctionExpression(declaration) || isArrowFunction(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : undefined);

}

/*@internal*/

export function getAssignedName(node: Node): DeclarationName | undefined {

if (!node.parent) {

return undefined;

}

else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) {

return node.parent.name;

}

else if (isBinaryExpression(node.parent) && node === node.parent.right) {

if (isIdentifier(node.parent.left)) {

return node.parent.left;

}

else if (isAccessExpression(node.parent.left)) {

return getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left);

}

}

else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) {

return node.parent.name;

}

}

function getJSDocParameterTagsWorker(param: ParameterDeclaration, noCache?: boolean): readonly JSDocParameterTag[] {

if (param.name) {

if (isIdentifier(param.name)) {

const name = param.name.escapedText;

return getJSDocTagsWorker(param.parent, noCache).filter((tag): tag is JSDocParameterTag => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);

}

else {

const i = param.parent.parameters.indexOf(param);

Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");

const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);

if (i < paramTags.length) {

return [paramTags[i]];

}

}

}

// return empty array for: out-of-order binding patterns and JSDoc function syntax, which has un-named parameters

return emptyArray;

}

/**

* Gets the JSDoc parameter tags for the node if present.

*

* @remarks Returns any JSDoc param tag whose name matches the provided

* parameter, whether a param tag on a containing function

* expression, or a param tag on a variable declaration whose

* initializer is the containing function. The tags closest to the

* node are returned first, so in the previous example, the param

* tag on the containing function expression would be first.

*

* For binding patterns, parameter tags are matched by position.

*/

export function getJSDocParameterTags(param: ParameterDeclaration): readonly JSDocParameterTag[] {

return getJSDocParameterTagsWorker(param, /*noCache*/ false);

}

/* @internal */

export function getJSDocParameterTagsNoCache(param: ParameterDeclaration): readonly JSDocParameterTag[] {

return getJSDocParameterTagsWorker(param, /*noCache*/ true);

}

function getJSDocTypeParameterTagsWorker(param: TypeParameterDeclaration, noCache?: boolean): readonly JSDocTemplateTag[] {

const name = param.name.escapedText;

return getJSDocTagsWorker(param.parent, noCache).filter((tag): tag is JSDocTemplateTag =>

isJSDocTemplateTag(tag) && tag.typeParameters.some(tp => tp.name.escapedText === name));

}

/**

* Gets the JSDoc type parameter tags for the node if present.

*

* @remarks Returns any JSDoc template tag whose names match the provided

* parameter, whether a template tag on a containing function

* expression, or a template tag on a variable declaration whose

* initializer is the containing function. The tags closest to the

* node are returned first, so in the previous example, the template

* tag on the containing function expression would be first.

*/

export function getJSDocTypeParameterTags(param: TypeParameterDeclaration): readonly JSDocTemplateTag[] {

return getJSDocTypeParameterTagsWorker(param, /*noCache*/ false);

}

/* @internal */

export function getJSDocTypeParameterTagsNoCache(param: TypeParameterDeclaration): readonly JSDocTemplateTag[] {

return getJSDocTypeParameterTagsWorker(param, /*noCache*/ true);

}

/**

* Return true if the node has JSDoc parameter tags.

*

* @remarks Includes parameter tags that are not directly on the node,

* for example on a variable declaration whose initializer is a function expression.

*/

export function hasJSDocParameterTags(node: FunctionLikeDeclaration | SignatureDeclaration): boolean {

return !!getFirstJSDocTag(node, isJSDocParameterTag);

}

/** Gets the JSDoc augments tag for the node if present */

export function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag | undefined {

return getFirstJSDocTag(node, isJSDocAugmentsTag);

}

/** Gets the JSDoc implements tags for the node if present */

export function getJSDocImplementsTags(node: Node): readonly JSDocImplementsTag[] {

return getAllJSDocTags(node, isJSDocImplementsTag);

}

/** Gets the JSDoc class tag for the node if present */

export function getJSDocClassTag(node: Node): JSDocClassTag | undefined {

return getFirstJSDocTag(node, isJSDocClassTag);

}

/** Gets the JSDoc public tag for the node if present */

export function getJSDocPublicTag(node: Node): JSDocPublicTag | undefined {

return getFirstJSDocTag(node, isJSDocPublicTag);

}

/*@internal*/

export function getJSDocPublicTagNoCache(node: Node): JSDocPublicTag | undefined {

return getFirstJSDocTag(node, isJSDocPublicTag, /*noCache*/ true);

}

/** Gets the JSDoc private tag for the node if present */

export function getJSDocPrivateTag(node: Node): JSDocPrivateTag | undefined {

return getFirstJSDocTag(node, isJSDocPrivateTag);

}

/*@internal*/

export function getJSDocPrivateTagNoCache(node: Node): JSDocPrivateTag | undefined {

return getFirstJSDocTag(node, isJSDocPrivateTag, /*noCache*/ true);

}

/** Gets the JSDoc protected tag for the node if present */

export function getJSDocProtectedTag(node: Node): JSDocProtectedTag | undefined {

return getFirstJSDocTag(node, isJSDocProtectedTag);

}

/*@internal*/

export function getJSDocProtectedTagNoCache(node: Node): JSDocProtectedTag | undefined {

return getFirstJSDocTag(node, isJSDocProtectedTag, /*noCache*/ true);

}

/** Gets the JSDoc protected tag for the node if present */

export function getJSDocReadonlyTag(node: Node): JSDocReadonlyTag | undefined {

return getFirstJSDocTag(node, isJSDocReadonlyTag);

}

/*@internal*/

export function getJSDocReadonlyTagNoCache(node: Node): JSDocReadonlyTag | undefined {

return getFirstJSDocTag(node, isJSDocReadonlyTag, /*noCache*/ true);

}

export function getJSDocOverrideTagNoCache(node: Node): JSDocOverrideTag | undefined {

return getFirstJSDocTag(node, isJSDocOverrideTag, /*noCache*/ true);

}

/** Gets the JSDoc deprecated tag for the node if present */

export function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined {

return getFirstJSDocTag(node, isJSDocDeprecatedTag);

}

/*@internal */

export function getJSDocDeprecatedTagNoCache(node: Node): JSDocDeprecatedTag | undefined {

return getFirstJSDocTag(node, isJSDocDeprecatedTag, /*noCache*/ true);

}

/** Gets the JSDoc enum tag for the node if present */

export function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined {

return getFirstJSDocTag(node, isJSDocEnumTag);

}

/** Gets the JSDoc this tag for the node if present */

export function getJSDocThisTag(node: Node): JSDocThisTag | undefined {

return getFirstJSDocTag(node, isJSDocThisTag);

}

/** Gets the JSDoc return tag for the node if present */

export function getJSDocReturnTag(node: Node): JSDocReturnTag | undefined {

return getFirstJSDocTag(node, isJSDocReturnTag);

}

/** Gets the JSDoc template tag for the node if present */

export function getJSDocTemplateTag(node: Node): JSDocTemplateTag | undefined {

return getFirstJSDocTag(node, isJSDocTemplateTag);

}

/** Gets the JSDoc type tag for the node if present and valid */

export function getJSDocTypeTag(node: Node): JSDocTypeTag | undefined {

// We should have already issued an error if there were multiple type jsdocs, so just use the first one.

const tag = getFirstJSDocTag(node, isJSDocTypeTag);

if (tag && tag.typeExpression && tag.typeExpression.type) {

return tag;

}

return undefined;

}

/**

* Gets the type node for the node if provided via JSDoc.

*

* @remarks The search includes any JSDoc param tag that relates

* to the provided parameter, for example a type tag on the

* parameter itself, or a param tag on a containing function

* expression, or a param tag on a variable declaration whose

* initializer is the containing function. The tags closest to the

* node are examined first, so in the previous example, the type

* tag directly on the node would be returned.

*/

export function getJSDocType(node: Node): TypeNode | undefined {

let tag: JSDocTypeTag | JSDocParameterTag | undefined = getFirstJSDocTag(node, isJSDocTypeTag);

if (!tag && isParameter(node)) {

tag = find(getJSDocParameterTags(node), tag => !!tag.typeExpression);

}

return tag && tag.typeExpression && tag.typeExpression.type;

}

/**

* Gets the return type node for the node if provided via JSDoc return tag or type tag.

*

* @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function

* gets the type from inside the braces, after the fat arrow, etc.

*/

export function getJSDocReturnType(node: Node): TypeNode | undefined {

const returnTag = getJSDocReturnTag(node);

if (returnTag && returnTag.typeExpression) {

return returnTag.typeExpression.type;

}

const typeTag = getJSDocTypeTag(node);

if (typeTag && typeTag.typeExpression) {

const type = typeTag.typeExpression.type;

if (isTypeLiteralNode(type)) {

const sig = find(type.members, isCallSignatureDeclaration);

return sig && sig.type;

}

if (isFunctionTypeNode(type) || isJSDocFunctionType(type)) {

return type.type;

}

}

}

function getJSDocTagsWorker(node: Node, noCache?: boolean): readonly JSDocTag[] {

let tags = (node as JSDocContainer).jsDocCache;

// If cache is 'null', that means we did the work of searching for JSDoc tags and came up with nothing.

if (tags === undefined || noCache) {

const comments = getJSDocCommentsAndTags(node, noCache);

Debug.assert(comments.length < 2 || comments[0] !== comments[1]);

tags = flatMap(comments, j => isJSDoc(j) ? j.tags : j);

if (!noCache) {

(node as JSDocContainer).jsDocCache = tags;

}

}

return tags;

}

/** Get all JSDoc tags related to a node, including those on parent nodes. */

export function getJSDocTags(node: Node): readonly JSDocTag[] {

return getJSDocTagsWorker(node, /*noCache*/ false);

}

/* @internal */

export function getJSDocTagsNoCache(node: Node): readonly JSDocTag[] {

return getJSDocTagsWorker(node, /*noCache*/ true);

}

/** Get the first JSDoc tag of a specified kind, or undefined if not present. */

function getFirstJSDocTag<T extends JSDocTag>(node: Node, predicate: (tag: JSDocTag) => tag is T, noCache?: boolean): T | undefined {

return find(getJSDocTagsWorker(node, noCache), predicate);

}

/** Gets all JSDoc tags that match a specified predicate */

export function getAllJSDocTags<T extends JSDocTag>(node: Node, predicate: (tag: JSDocTag) => tag is T): readonly T[] {

return getJSDocTags(node).filter(predicate);

}

/** Gets all JSDoc tags of a specified kind */

export function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): readonly JSDocTag[] {

return getJSDocTags(node).filter(doc => doc.kind === kind);

}

/** Gets the text of a jsdoc comment, flattening links to their text. */

export function getTextOfJSDocComment(comment?: string | NodeArray<JSDocComment>) {

return typeof comment === "string" ? comment

: comment?.map(c => c.kind === SyntaxKind.JSDocText ? c.text : formatJSDocLink(c)).join("");

}

function formatJSDocLink(link: JSDocLink | JSDocLinkCode | JSDocLinkPlain) {

const kind = link.kind === SyntaxKind.JSDocLink ? "link"

: link.kind === SyntaxKind.JSDocLinkCode ? "linkcode"

: "linkplain";

const name = link.name ? entityNameToString(link.name) : "";

const space = link.name && link.text.startsWith("://") ? "" : " ";

return `{@${kind} ${name}${space}${link.text}}`;

}

/**

* Gets the effective type parameters. If the node was parsed in a

* JavaScript file, gets the type parameters from the `@template` tag from JSDoc.

*/

export function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): readonly TypeParameterDeclaration[] {

if (isJSDocSignature(node)) {

return emptyArray;

}

if (isJSDocTypeAlias(node)) {

Debug.assert(node.parent.kind === SyntaxKind.JSDoc);

return flatMap(node.parent.tags, tag => isJSDocTemplateTag(tag) ? tag.typeParameters : undefined);

}

if (node.typeParameters) {

return node.typeParameters;

}

if (isInJSFile(node)) {

const decls = getJSDocTypeParameterDeclarations(node);

if (decls.length) {

return decls;

}

const typeTag = getJSDocType(node);

if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) {

return typeTag.typeParameters;

}

}

return emptyArray;

}

export function getEffectiveConstraintOfTypeParameter(node: TypeParameterDeclaration): TypeNode | undefined {

return node.constraint ? node.constraint :

isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint :

undefined;

}

// #region

export function isMemberName(node: Node): node is MemberName {

return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;

}

/* @internal */

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

return node.kind === SyntaxKind.SetAccessor || node.kind === SyntaxKind.GetAccessor;

}

export function isPropertyAccessChain(node: Node): node is PropertyAccessChain {

return isPropertyAccessExpression(node) && !!(node.flags & NodeFlags.OptionalChain);

}

export function isElementAccessChain(node: Node): node is ElementAccessChain {

return isElementAccessExpression(node) && !!(node.flags & NodeFlags.OptionalChain);

}

export function isCallChain(node: Node): node is CallChain {

return isCallExpression(node) && !!(node.flags & NodeFlags.OptionalChain);

}

export function isOptionalChain(node: Node): node is PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain {

const kind = node.kind;

return !!(node.flags & NodeFlags.OptionalChain) &&

(kind === SyntaxKind.PropertyAccessExpression

|| kind === SyntaxKind.ElementAccessExpression

|| kind === SyntaxKind.CallExpression

|| kind === SyntaxKind.NonNullExpression);

}

/* @internal */

export function isOptionalChainRoot(node: Node): node is OptionalChainRoot {

return isOptionalChain(node) && !isNonNullExpression(node) && !!node.questionDotToken;

}

/**

* Determines whether a node is the expression preceding an optional chain (i.e. `a` in `a?.b`).

*/

/* @internal */

export function isExpressionOfOptionalChainRoot(node: Node): node is Expression & { parent: OptionalChainRoot } {

return isOptionalChainRoot(node.parent) && node.parent.expression === node;

}

/**

* Determines whether a node is the outermost `OptionalChain` in an ECMAScript `OptionalExpression`: