add(value: NameAndKind): void;

has(name: string): boolean;

values(): Iterator<NameAndKind>;

const map = new Map<string, NameAndKind>();

function add(value: NameAndKind) {

const existing = map.get(value.name);

if (!existing || kindPrecedence[existing.kind] < kindPrecedence[value.kind]) {

map.set(value.name, value);

}

}

return {

add,

has: map.has.bind(map),

values: map.values.bind(map),

};

sourceFile: SourceFile,

position: number,

contextToken: Node | undefined,

options: CompilerOptions,

host: LanguageServiceHost,

program: Program,

log: Log,

preferences: UserPreferences): CompletionInfo | undefined {

if (isInReferenceComment(sourceFile, position)) {

const entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);

return entries && convertPathCompletions(entries);

}

if (isInString(sourceFile, position, contextToken)) {

if (!contextToken || !isStringLiteralLike(contextToken)) return undefined;

const entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, program.getTypeChecker(), options, host, preferences);

return convertStringLiteralCompletions(entries, contextToken, sourceFile, host, program, log, options, preferences);

}

completion: StringLiteralCompletion | undefined,

contextToken: StringLiteralLike,

sourceFile: SourceFile,

host: LanguageServiceHost,

program: Program,

log: Log,

options: CompilerOptions,

preferences: UserPreferences,

): CompletionInfo | undefined {

if (completion === undefined) {

return undefined;

}

const optionalReplacementSpan = createTextSpanFromStringLiteralLikeContent(contextToken);

switch (completion.kind) {

case StringLiteralCompletionKind.Paths:

return convertPathCompletions(completion.paths);

case StringLiteralCompletionKind.Properties: {

const entries = createSortedArray<CompletionEntry>();

getCompletionEntriesFromSymbols(

completion.symbols,

entries,

contextToken,

contextToken,

sourceFile,

sourceFile,

host,

program,

ScriptTarget.ESNext,

log,

CompletionKind.String,

preferences,

options,

/*formatContext*/ undefined,

); // Target will not be used, so arbitrary

return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan, entries };

}

case StringLiteralCompletionKind.Types: {

const entries = completion.types.map(type => ({

name: type.value,

kindModifiers: ScriptElementKindModifier.none,

kind: ScriptElementKind.string,

sortText: SortText.LocationPriority,

replacementSpan: getReplacementSpanForContextToken(contextToken)

}));

return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: completion.isNewIdentifier, optionalReplacementSpan, entries };

}

default:

return Debug.assertNever(completion);

}

if (!contextToken || !isStringLiteralLike(contextToken)) return undefined;

const completions = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker, options, host, preferences);

return completions && stringLiteralCompletionDetails(name, contextToken, completions, sourceFile, checker, cancellationToken);

switch (completion.kind) {

case StringLiteralCompletionKind.Paths: {

const match = find(completion.paths, p => p.name === name);

return match && createCompletionDetails(name, kindModifiersFromExtension(match.extension), match.kind, [textPart(name)]);

}

case StringLiteralCompletionKind.Properties: {

const match = find(completion.symbols, s => s.name === name);

return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken);

}

case StringLiteralCompletionKind.Types:

return find(completion.types, t => t.value === name) ? createCompletionDetails(name, ScriptElementKindModifier.none, ScriptElementKind.typeElement, [textPart(name)]) : undefined;

default:

return Debug.assertNever(completion);

}

const isGlobalCompletion = false; // We don't want the editor to offer any other completions, such as snippets, inside a comment.

const isNewIdentifierLocation = true; // The user may type in a path that doesn't yet exist, creating a "new identifier" with respect to the collection of identifiers the server is aware of.

const entries = pathCompletions.map(({ name, kind, span, extension }): CompletionEntry =>

({ name, kind, kindModifiers: kindModifiersFromExtension(extension), sortText: SortText.LocationPriority, replacementSpan: span }));

return { isGlobalCompletion, isMemberCompletion: false, isNewIdentifierLocation, entries };

switch (extension) {

case Extension.Dts: return ScriptElementKindModifier.dtsModifier;

case Extension.Js: return ScriptElementKindModifier.jsModifier;

case Extension.Json: return ScriptElementKindModifier.jsonModifier;

case Extension.Jsx: return ScriptElementKindModifier.jsxModifier;

case Extension.Ts: return ScriptElementKindModifier.tsModifier;

case Extension.Tsx: return ScriptElementKindModifier.tsxModifier;

case Extension.Dmts: return ScriptElementKindModifier.dmtsModifier;

case Extension.Mjs: return ScriptElementKindModifier.mjsModifier;

case Extension.Mts: return ScriptElementKindModifier.mtsModifier;

case Extension.Dcts: return ScriptElementKindModifier.dctsModifier;

case Extension.Cjs: return ScriptElementKindModifier.cjsModifier;

case Extension.Cts: return ScriptElementKindModifier.ctsModifier;

case Extension.TsBuildInfo: return Debug.fail(`Extension ${Extension.TsBuildInfo} is unsupported.`);

case undefined: return ScriptElementKindModifier.none;

default:

return Debug.assertNever(extension);

}

readonly kind: StringLiteralCompletionKind.Properties;

readonly symbols: readonly Symbol[];

readonly hasIndexSignature: boolean;

readonly kind: StringLiteralCompletionKind.Types;

readonly types: readonly StringLiteralType[];

readonly isNewIdentifier: boolean;

const parent = walkUpParentheses(node.parent);

switch (parent.kind) {

case SyntaxKind.LiteralType: {

const grandParent = walkUpParentheses(parent.parent);

switch (grandParent.kind) {

case SyntaxKind.ExpressionWithTypeArguments:

case SyntaxKind.TypeReference: {

const typeArgument = findAncestor(parent, n => n.parent === grandParent) as LiteralTypeNode;

if (typeArgument) {

return { kind: StringLiteralCompletionKind.Types, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(typeArgument)), isNewIdentifier: false };

}

return undefined;

}

case SyntaxKind.IndexedAccessType:

// Get all apparent property names

// i.e. interface Foo {

// foo: string;

// bar: string;

// }

// let x: Foo["/*completion position*/"]

const { indexType, objectType } = grandParent as IndexedAccessTypeNode;

if (!rangeContainsPosition(indexType, position)) {

return undefined;

}

return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode(objectType));

case SyntaxKind.ImportType:

return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };

case SyntaxKind.UnionType: {

if (!isTypeReferenceNode(grandParent.parent)) {

return undefined;

}

const alreadyUsedTypes = getAlreadyUsedTypesInStringLiteralUnion(grandParent as UnionTypeNode, parent as LiteralTypeNode);

const types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(grandParent as UnionTypeNode)).filter(t => !contains(alreadyUsedTypes, t.value));

return { kind: StringLiteralCompletionKind.Types, types, isNewIdentifier: false };

}

default:

return undefined;

}

}

case SyntaxKind.PropertyAssignment:

if (isObjectLiteralExpression(parent.parent) && (parent as PropertyAssignment).name === node) {

// Get quoted name of properties of the object literal expression

// i.e. interface ConfigFiles {

// 'jspm:dev': string

// }

// let files: ConfigFiles = {

// '/*completion position*/'

// }

//

// function foo(c: ConfigFiles) {}

// foo({

// '/*completion position*/'

// });

return stringLiteralCompletionsForObjectLiteral(typeChecker, parent.parent);

}

return fromContextualType();

case SyntaxKind.ElementAccessExpression: {

const { expression, argumentExpression } = parent as ElementAccessExpression;

if (node === skipParentheses(argumentExpression)) {

// Get all names of properties on the expression

// i.e. interface A {

// 'prop1': string

// }

// let a: A;

// a['/*completion position*/']

return stringLiteralCompletionsFromProperties(typeChecker.getTypeAtLocation(expression));

}

return undefined;

}

case SyntaxKind.CallExpression:

case SyntaxKind.NewExpression:

case SyntaxKind.JsxAttribute:

if (!isRequireCallArgument(node) && !isImportCall(parent)) {

const argumentInfo = SignatureHelp.getArgumentInfoForCompletions(parent.kind === SyntaxKind.JsxAttribute ? parent.parent : node, position, sourceFile);

// Get string literal completions from specialized signatures of the target

// i.e. declare function f(a: 'A');

// f("/*completion position*/")

return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType();

}

// falls through (is `require("")` or `require(""` or `import("")`)

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ExportDeclaration:

case SyntaxKind.ExternalModuleReference:

// Get all known external module names or complete a path to a module

// i.e. import * as ns from "/*completion position*/";

// var y = import("/*completion position*/");

// import x = require("/*completion position*/");

// var y = require("/*completion position*/");

// export * from "/*completion position*/";

return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };

default:

return fromContextualType();

}

function fromContextualType(): StringLiteralCompletion {

// Get completion for string literal from string literal type

// i.e. var x: "hi" | "hello" = "/*completion position*/"

return { kind: StringLiteralCompletionKind.Types, types: getStringLiteralTypes(getContextualTypeFromParent(node, typeChecker)), isNewIdentifier: false };

}

switch (node.kind) {

case SyntaxKind.ParenthesizedType:

return walkUpParenthesizedTypes(node);

case SyntaxKind.ParenthesizedExpression:

return walkUpParenthesizedExpressions(node);

default:

return node;

}

let isNewIdentifier = false;

const uniques = new Map<string, true>();

const candidates: Signature[] = [];

const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg;

checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates);

const types = flatMap(candidates, candidate => {

if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length) return;

let type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex);

if (isJsxOpeningLikeElement(call)) {

const propType = checker.getTypeOfPropertyOfType(type, (editingArgument as JsxAttribute).name.text);

if (propType) {

type = propType;

}

}

isNewIdentifier = isNewIdentifier || !!(type.flags & TypeFlags.String);

return getStringLiteralTypes(type, uniques);

});

return length(types) ? { kind: StringLiteralCompletionKind.Types, types, isNewIdentifier } : undefined;

return type && {

kind: StringLiteralCompletionKind.Properties,

symbols: filter(type.getApparentProperties(), prop => !(prop.valueDeclaration && isPrivateIdentifierClassElementDeclaration(prop.valueDeclaration))),

hasIndexSignature: hasIndexSignature(type)

};

const contextualType = checker.getContextualType(objectLiteralExpression);

if (!contextualType) return undefined;

const completionsType = checker.getContextualType(objectLiteralExpression, ContextFlags.Completions);

const symbols = getPropertiesForObjectExpression(

contextualType,

completionsType,

objectLiteralExpression,

checker

);

return {

kind: StringLiteralCompletionKind.Properties,

symbols,

hasIndexSignature: hasIndexSignature(contextualType)

};

if (!type) return emptyArray;

type = skipConstraint(type);

return type.isUnion() ? flatMap(type.types, t => getStringLiteralTypes(t, uniques)) :

type.isStringLiteral() && !(type.flags & TypeFlags.EnumLiteral) && addToSeen(uniques, type.value) ? [type] : emptyArray;

readonly name: string;

readonly kind: ScriptElementKind.scriptElement | ScriptElementKind.directory | ScriptElementKind.externalModuleName;

readonly extension: Extension | undefined;

const span = getDirectoryFragmentTextSpan(text, textStart);

const wholeSpan = text.length === 0 ? undefined : createTextSpan(textStart, text.length);

return names.map(({ name, kind, extension }): PathCompletion =>

Math.max(name.indexOf(directorySeparator), name.indexOf(altDirectorySeparator)) !== -1 ? { name, kind, extension, span: wholeSpan } : { name, kind, extension, span });

const literalValue = normalizeSlashes(node.text);

const mode = isStringLiteralLike(node) ? getModeForUsageLocation(sourceFile, node) : undefined;

const scriptPath = sourceFile.path;

const scriptDirectory = getDirectoryPath(scriptPath);

return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && (isRootedDiskPath(literalValue) || isUrl(literalValue))

? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, getIncludeExtensionOption())

: getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, getIncludeExtensionOption(), typeChecker);

function getIncludeExtensionOption() {

const mode = isStringLiteralLike(node) ? getModeForUsageLocation(sourceFile, node) : undefined;

return preferences.importModuleSpecifierEnding === "js" || mode === ModuleKind.ESNext ? IncludeExtensionsOption.ModuleSpecifierCompletion : IncludeExtensionsOption.Exclude;

}

const extensionOptions = getExtensionOptions(compilerOptions, includeExtensions);

if (compilerOptions.rootDirs) {

return getCompletionEntriesForDirectoryFragmentWithRootDirs(

compilerOptions.rootDirs, literalValue, scriptDirectory, extensionOptions, compilerOptions, host, scriptPath);

}

else {

return arrayFrom(getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath).values());

}

return getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.NodeJs ||

getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.Node16 ||

getEmitModuleResolutionKind(compilerOptions) === ModuleResolutionKind.NodeNext;

const extensions = getSupportedExtensions(compilerOptions);

return isEmitResolutionKindUsingNodeModules(compilerOptions) ?

getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, extensions) :

extensions;

// Make all paths absolute/normalized if they are not already

rootDirs = rootDirs.map(rootDirectory => normalizePath(isRootedDiskPath(rootDirectory) ? rootDirectory : combinePaths(basePath, rootDirectory)));

// Determine the path to the directory containing the script relative to the root directory it is contained within

const relativeDirectory = firstDefined(rootDirs, rootDirectory =>

containsPath(rootDirectory, scriptDirectory, basePath, ignoreCase) ? scriptDirectory.substr(rootDirectory.length) : undefined)!; // TODO: GH#18217

// Now find a path for each potential directory that is to be merged with the one containing the script

return deduplicate<string>(

[...rootDirs.map(rootDirectory => combinePaths(rootDirectory, relativeDirectory)), scriptDirectory],

equateStringsCaseSensitive,

compareStringsCaseSensitive);

const basePath = compilerOptions.project || host.getCurrentDirectory();

const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());

const baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase);

return flatMap(baseDirectories, baseDirectory => arrayFrom(getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensionOptions, host, exclude).values()));

Exclude,

Include,

ModuleSpecifierCompletion,

fragment: string,

scriptPath: string,

extensionOptions: ExtensionOptions,

host: LanguageServiceHost,

exclude?: string,

result = createNameAndKindSet()

): NameAndKindSet {

if (fragment === undefined) {

fragment = "";

}

fragment = normalizeSlashes(fragment);

/**

if (!hasTrailingDirectorySeparator(fragment)) {

fragment = getDirectoryPath(fragment);

}

if (fragment === "") {

fragment = "." + directorySeparator;

}

fragment = ensureTrailingDirectorySeparator(fragment);

const absolutePath = resolvePath(scriptPath, fragment);

const baseDirectory = hasTrailingDirectorySeparator(absolutePath) ? absolutePath : getDirectoryPath(absolutePath);

// check for a version redirect

const packageJsonPath = findPackageJson(baseDirectory, host);

if (packageJsonPath) {

const packageJson = readJson(packageJsonPath, host as { readFile: (filename: string) => string | undefined });

const typesVersions = (packageJson as any).typesVersions;

if (typeof typesVersions === "object") {

const versionPaths = getPackageJsonTypesVersionsPaths(typesVersions)?.paths;

if (versionPaths) {

const packageDirectory = getDirectoryPath(packageJsonPath);

const pathInPackage = absolutePath.slice(ensureTrailingDirectorySeparator(packageDirectory).length);

if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, host, versionPaths)) {

// A true result means one of the `versionPaths` was matched, which will block relative resolution

// to files and folders from here. All reachable paths given the pattern match are already added.

return result;

}

}

}

}

const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());

if (!tryDirectoryExists(host, baseDirectory)) return result;

// Enumerate the available files if possible

const files = tryReadDirectory(host, baseDirectory, extensionOptions.extensions, /*exclude*/ undefined, /*include*/ ["./*"]);

if (files) {

for (let filePath of files) {

filePath = normalizePath(filePath);

if (exclude && comparePaths(filePath, exclude, scriptPath, ignoreCase) === Comparison.EqualTo) {

continue;

}

const { name, extension } = getFilenameWithExtensionOption(getBaseFileName(filePath), host.getCompilationSettings(), extensionOptions.includeExtensionsOption);

result.add(nameAndKind(name, ScriptElementKind.scriptElement, extension));

}

}

// If possible, get folder completion as well

const directories = tryGetDirectories(host, baseDirectory);

if (directories) {

for (const directory of directories) {

const directoryName = getBaseFileName(normalizePath(directory));

if (directoryName !== "@types") {

result.add(directoryResult(directoryName));

}

}

}

return result;

const outputExtension = moduleSpecifiers.tryGetJSExtensionForFile(name, compilerOptions);

if (includeExtensionsOption === IncludeExtensionsOption.Exclude && !fileExtensionIsOneOf(name, [Extension.Json, Extension.Mts, Extension.Cts, Extension.Dmts, Extension.Dcts, Extension.Mjs, Extension.Cjs])) {

return { name: removeFileExtension(name), extension: tryGetExtensionFromPath(name) };

}

else if ((fileExtensionIsOneOf(name, [Extension.Mts, Extension.Cts, Extension.Dmts, Extension.Dcts, Extension.Mjs, Extension.Cjs]) || includeExtensionsOption === IncludeExtensionsOption.ModuleSpecifierCompletion) && outputExtension) {

return { name: changeExtension(name, outputExtension), extension: outputExtension };

}

else {

return { name, extension: tryGetExtensionFromPath(name) };

}

result: NameAndKindSet,

fragment: string,

baseDirectory: string,

extensionOptions: ExtensionOptions,

host: LanguageServiceHost,

paths: MapLike<string[]>

) {

const getPatternsForKey = (key: string) => paths[key];

const comparePaths = (a: string, b: string): Comparison => {

const patternA = tryParsePattern(a);

const patternB = tryParsePattern(b);

const lengthA = typeof patternA === "object" ? patternA.prefix.length : a.length;

const lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length;

return compareValues(lengthB, lengthA);

};

return addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, getOwnKeys(paths), getPatternsForKey, comparePaths);

result: NameAndKindSet,

fragment: string,

baseDirectory: string,

extensionOptions: ExtensionOptions,

host: LanguageServiceHost,

keys: readonly string[],

getPatternsForKey: (key: string) => string[] | undefined,

comparePaths: (a: string, b: string) => Comparison,

) {

let pathResults: { results: NameAndKind[], matchedPattern: boolean }[] = [];

let matchedPath: string | undefined;

for (const key of keys) {

if (key === ".") continue;

const keyWithoutLeadingDotSlash = key.replace(/^\.\//, ""); // remove leading "./"

const patterns = getPatternsForKey(key);

if (patterns) {

const pathPattern = tryParsePattern(keyWithoutLeadingDotSlash);

if (!pathPattern) continue;

const isMatch = typeof pathPattern === "object" && isPatternMatch(pathPattern, fragment);

const isLongestMatch = isMatch && (matchedPath === undefined || comparePaths(key, matchedPath) === Comparison.LessThan);

if (isLongestMatch) {

// If this is a higher priority match than anything we've seen so far, previous results from matches are invalid, e.g.

// for `import {} from "some-package/|"` with a typesVersions:

// {

// "bar/*": ["bar/*"], // <-- 1. We add 'bar', but 'bar/*' doesn't match yet.

// "*": ["dist/*"], // <-- 2. We match here and add files from dist. 'bar' is still ok because it didn't come from a match.

// "foo/*": ["foo/*"] // <-- 3. We matched '*' earlier and added results from dist, but if 'foo/*' also matched,

// } results in dist would not be visible. 'bar' still stands because it didn't come from a match.

// This is especially important if `dist/foo` is a folder, because if we fail to clear results

// added by the '*' match, after typing `"some-package/foo/|"` we would get file results from both

// ./dist/foo and ./foo, when only the latter will actually be resolvable.

// See pathCompletionsTypesVersionsWildcard6.ts.

matchedPath = key;

pathResults = pathResults.filter(r => !r.matchedPattern);

}

if (typeof pathPattern === "string" || matchedPath === undefined || comparePaths(key, matchedPath) !== Comparison.GreaterThan) {

pathResults.push({

matchedPattern: isMatch,

results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, host)