diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 51cee644b170d..f3c2bc1a55cee 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1650,12 +1650,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { getFullyQualifiedName, getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, CheckMode.Normal), - getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray, checkMode = CheckMode.IsForStringLiteralArgumentCompletions) => { - if (checkMode & CheckMode.IsForStringLiteralArgumentCompletions) { - return runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, checkMode & ~CheckMode.IsForStringLiteralArgumentCompletions)); - } - return runWithoutResolvedSignatureCaching(editingArgument, () => getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, checkMode & ~CheckMode.IsForStringLiteralArgumentCompletions)); - }, + getCandidateSignaturesForStringLiteralCompletions, getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, CheckMode.IsForSignatureHelp)), getExpandedParameters, @@ -1836,6 +1831,28 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { typeHasCallOrConstructSignatures, }; + function getCandidateSignaturesForStringLiteralCompletions(call: CallLikeExpression, editingArgument: Node) { + const candidatesSet = new Set(); + const candidates: Signature[] = []; + + // first, get candidates when inference is blocked from the source node. + runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(call, candidates, /*argumentCount*/ undefined, CheckMode.IsForStringLiteralArgumentCompletions)); + for (const candidate of candidates) { + candidatesSet.add(candidate); + } + + // reset candidates for second pass + candidates.length = 0; + + // next, get candidates where the source node is considered for inference. + runWithoutResolvedSignatureCaching(editingArgument, () => getResolvedSignatureWorker(call, candidates, /*argumentCount*/ undefined, CheckMode.IsForStringLiteralArgumentCompletions)); + for (const candidate of candidates) { + candidatesSet.add(candidate); + } + + return arrayFrom(candidatesSet); + } + function runWithoutResolvedSignatureCaching(node: Node | undefined, fn: () => T): T { const cachedSignatures = []; while (node) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 5432adf33ebb5..a5a69fcee2ad6 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1,6 +1,5 @@ import { BaseNodeFactory, - CheckMode, CreateSourceFileOptions, EmitHelperFactory, GetCanonicalFileName, @@ -5081,7 +5080,7 @@ export interface TypeChecker { */ getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; /** @internal */ getResolvedSignatureForSignatureHelp(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; - /** @internal */ getResolvedSignatureForStringLiteralCompletions(call: CallLikeExpression, editingArgument: Node, candidatesOutArray: Signature[], checkMode?: CheckMode): Signature | undefined; + /** @internal */ getCandidateSignaturesForStringLiteralCompletions(call: CallLikeExpression, editingArgument: Node): Signature[]; /** @internal */ getExpandedParameters(sig: Signature): readonly (readonly Symbol[])[]; /** @internal */ hasEffectiveRestParameter(sig: Signature): boolean; /** @internal */ containsArgumentsReference(declaration: SignatureDeclaration): boolean; diff --git a/src/services/stringCompletions.ts b/src/services/stringCompletions.ts index bb41bf4d594bc..6b30450a74579 100644 --- a/src/services/stringCompletions.ts +++ b/src/services/stringCompletions.ts @@ -7,7 +7,6 @@ import { CaseClause, changeExtension, CharacterCodes, - CheckMode, combinePaths, comparePaths, comparePatternKeys, @@ -117,7 +116,6 @@ import { ScriptElementKind, ScriptElementKindModifier, ScriptTarget, - Signature, signatureHasRestParameter, SignatureHelp, singleElementArray, @@ -390,7 +388,7 @@ function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringL // 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) || getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker, CheckMode.Normal)) || fromContextualType(ContextFlags.None); + return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType(ContextFlags.None); } // falls through (is `require("")` or `require(""` or `import("")`) @@ -481,12 +479,11 @@ function getAlreadyUsedTypesInStringLiteralUnion(union: UnionTypeNode, current: type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : undefined); } -function getStringLiteralCompletionsFromSignature(call: CallLikeExpression, arg: StringLiteralLike, argumentInfo: SignatureHelp.ArgumentInfoForCompletions, checker: TypeChecker, checkMode = CheckMode.IsForStringLiteralArgumentCompletions): StringLiteralCompletionsFromTypes | undefined { +function getStringLiteralCompletionsFromSignature(call: CallLikeExpression, arg: StringLiteralLike, argumentInfo: SignatureHelp.ArgumentInfoForCompletions, checker: TypeChecker): StringLiteralCompletionsFromTypes | undefined { let isNewIdentifier = false; const uniques = new Map(); - const candidates: Signature[] = []; const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg; - checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates, checkMode); + const candidates = checker.getCandidateSignaturesForStringLiteralCompletions(call, editingArgument); const types = flatMap(candidates, candidate => { if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length) return; let type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex); diff --git a/tests/cases/fourslash/stringLiteralCompletionsForGenericConditionalTypesUsingTemplateLiteralTypes.ts b/tests/cases/fourslash/stringLiteralCompletionsForGenericConditionalTypesUsingTemplateLiteralTypes.ts new file mode 100644 index 0000000000000..0074976300ce3 --- /dev/null +++ b/tests/cases/fourslash/stringLiteralCompletionsForGenericConditionalTypesUsingTemplateLiteralTypes.ts @@ -0,0 +1,14 @@ +/// + +// repro from https://github.com/microsoft/TypeScript/issues/49680 + +//// type PathOf = +//// K extends `${infer U}.${infer V}` +//// ? U extends keyof T ? PathOf : `${P}${keyof T & (string | number)}` +//// : K extends keyof T ? `${P}${K}` : `${P}${keyof T & (string | number)}`; +//// +//// declare function consumer(path: PathOf<{a: string, b: {c: string}}, K>) : number; +//// +//// consumer('b./*ts*/') + +verify.completions({ marker: ["ts"], exact: ["a", "b", "b.c"] }); diff --git a/tests/cases/fourslash/stringLiteralCompletionsFromGenericConditionalTypesUsingTemplateLiteralTypes.ts b/tests/cases/fourslash/stringLiteralCompletionsFromGenericConditionalTypesUsingTemplateLiteralTypes.ts new file mode 100644 index 0000000000000..da203a444d129 --- /dev/null +++ b/tests/cases/fourslash/stringLiteralCompletionsFromGenericConditionalTypesUsingTemplateLiteralTypes.ts @@ -0,0 +1,35 @@ +/// + +// @strict: true + +// repro from https://github.com/microsoft/TypeScript/issues/53997 + +//// type keyword = "foo" | "bar" | "baz" +//// +//// type validateString = s extends keyword +//// ? s +//// : s extends `${infer left extends keyword}|${infer right}` +//// ? right extends keyword +//// ? s +//// : `${left}|${keyword}` +//// : keyword +//// +//// type isUnknown = unknown extends t +//// ? [t] extends [{}] +//// ? false +//// : true +//// : false +//// +//// type validate = def extends string +//// ? validateString +//// : isUnknown extends true +//// ? keyword +//// : { +//// [k in keyof def]: validate +//// } +//// const parse = (def: validate) => def +//// const shallowExpression = parse("foo|/*ts*/") +//// const nestedExpression = parse({ prop: "foo|/*ts2*/" }) + +verify.completions({ marker: ["ts"], exact: ["foo|foo", "foo|bar", "foo|baz"] }); +verify.completions({ marker: ["ts2"], exact: ["foo|foo", "foo|bar", "foo|baz"] }); diff --git a/tests/cases/fourslash/stringLiteralCompletionsInPositionTypedUsingRest.ts b/tests/cases/fourslash/stringLiteralCompletionsInPositionTypedUsingRest.ts new file mode 100644 index 0000000000000..bd4a11eac9e00 --- /dev/null +++ b/tests/cases/fourslash/stringLiteralCompletionsInPositionTypedUsingRest.ts @@ -0,0 +1,21 @@ +/// + +// repro from https://github.com/microsoft/TypeScript/issues/49680#issuecomment-1249191842 + +//// declare function pick(obj: T, ...keys: K[]): Pick; +//// declare function pick2(obj: T, ...keys: K): Pick; +//// +//// const obj = { aaa: 1, bbb: '2', ccc: true }; +//// +//// pick(obj, 'aaa', '/*ts1*/'); +//// pick2(obj, 'aaa', '/*ts2*/'); + +// repro from https://github.com/microsoft/TypeScript/issues/49680#issuecomment-1273677941 + +//// class Q { +//// public select(...args: Keys[]) {} +//// } +//// new Q<{ id: string; name: string }>().select("name", "/*ts3*/"); + +verify.completions({ marker: ["ts1", "ts2"], exact: ["aaa", "bbb", "ccc"] }); +verify.completions({ marker: ["ts3"], exact: ["name", "id"] });