Try something

Author: andrewbranch

src/compiler/checker.ts

@@ -570,6 +570,8 @@ namespace ts {
             getFullyQualifiedName,
             getResolvedSignature: (node, candidatesOutArray, argumentCount) =>
                 getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, CheckMode.Normal),
+            getResolvedSignatureForStringLiteralCompletions: (node, candidatesOutArray, argumentCount, argumentIndex) =>
+                getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, CheckMode.Normal, argumentIndex),
             getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) =>
                 getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, CheckMode.IsForSignatureHelp),
             getExpandedParameters,
@@ -739,8 +741,31 @@ namespace ts {
             getMemberOverrideModifierStatus,
         };
 
-        function getResolvedSignatureWorker(nodeIn: CallLikeExpression, candidatesOutArray: Signature[] | undefined, argumentCount: number | undefined, checkMode: CheckMode): Signature | undefined {
-            const node = getParseTreeNode(nodeIn, isCallLikeExpression);
+        function getResolvedSignatureWorker(nodeIn: CallLikeExpression, candidatesOutArray: Signature[] | undefined, argumentCount: number | undefined, checkMode: CheckMode, argumentIndex?: number): Signature | undefined {
+            let node = getParseTreeNode(nodeIn, isCallLikeExpression);
+            if (node && argumentIndex !== undefined) {
+                const replacementArg = setParentRecursive(factory.createAsExpression(factory.createStringLiteral(""), factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword)), /*incremental*/ false);
+                switch (node.kind) {
+                    case SyntaxKind.CallExpression:
+                        node = factory.updateCallExpression(node, node.expression, node.typeArguments, [
+                            ...node.arguments.slice(0, argumentIndex),
+                            replacementArg,
+                            ...node.arguments.slice(argumentIndex + 1),
+                        ]);
+                        break;
+                    case SyntaxKind.NewExpression:
+                        node = factory.updateNewExpression(node, node.expression, node.typeArguments, [
+                            ...node.arguments?.slice(0, argumentIndex) || emptyArray,
+                            replacementArg,
+                            ...node.arguments?.slice(argumentIndex + 1) || emptyArray,
+                        ]);
+                        break;
+                    default:
+                        Debug.failBadSyntaxKind(node);
+                }
+                setParent(replacementArg, node);
+                setParent(node, nodeIn.parent);
+            }
             apparentArgumentCount = argumentCount;
             const res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
             apparentArgumentCount = undefined;

src/compiler/types.ts

@@ -4278,6 +4278,7 @@ namespace ts {
          * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
          */
         getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
+        /* @internal */ getResolvedSignatureForStringLiteralCompletions(node: CallExpression | NewExpression, candidatesOutArray: Signature[], argumentCount: number, argumentIndex: number): Signature | undefined;
         /* @internal */ getResolvedSignatureForSignatureHelp(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
         /* @internal */ getExpandedParameters(sig: Signature): readonly (readonly Symbol[])[];
         /* @internal */ hasEffectiveRestParameter(sig: Signature): boolean;

src/services/stringCompletions.ts

@@ -215,7 +215,7 @@ namespace ts.Completions.StringCompletions {
                     // Get string literal completions from specialized signatures of the target
                     // i.e. declare function f(a: 'A');
                     // f("/*completion position*/")
-                    return argumentInfo ? getStringLiteralCompletionsFromSignature(argumentInfo, typeChecker) : fromContextualType();
+                    return argumentInfo ? getStringLiteralCompletionsFromSignature(parent as CallExpression | NewExpression, argumentInfo, typeChecker) : fromContextualType();
                 }
                 // falls through (is `require("")` or `require(""` or `import("")`)
 
@@ -257,12 +257,12 @@ namespace ts.Completions.StringCompletions {
             type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : undefined);
     }
 
-    function getStringLiteralCompletionsFromSignature(argumentInfo: SignatureHelp.ArgumentInfoForCompletions, checker: TypeChecker): StringLiteralCompletionsFromTypes {
+    function getStringLiteralCompletionsFromSignature(node: CallExpression | NewExpression, argumentInfo: SignatureHelp.ArgumentInfoForCompletions, checker: TypeChecker): StringLiteralCompletionsFromTypes {
         let isNewIdentifier = false;
 
         const uniques = new Map<string, true>();
         const candidates: Signature[] = [];
-        checker.getResolvedSignature(argumentInfo.invocation, candidates, argumentInfo.argumentCount);
+        checker.getResolvedSignatureForStringLiteralCompletions(node, candidates, argumentInfo.argumentCount, argumentInfo.argumentIndex);
         const types = flatMap(candidates, candidate => {
             if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length) return;
             const type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex);

tests/cases/fourslash/completionsLiteralOverload.ts

@@ -1,14 +1,25 @@
 /// <reference path="fourslash.ts" />
 
+// @allowJs: true
+
+// @Filename: /a.tsx
 //// interface Events {
+////   "": any;
 ////   drag: any;
 ////   dragenter: any;
 //// }
 //// declare function addListener<K extends keyof Events>(type: K, listener: (ev: Events[K]) => any): void;
 //// declare function addListener(type: string, listener: (ev: any) => any): void;
 ////
-//// addListener("/**/");
+//// declare function ListenerComponent<K extends keyof Events>(props: { type: K, onWhatever: (ev: Events[K]) => void }): JSX.Element;
+////
+//// addListener("/*ts*/");
+//// (<ListenerComponent type="/*tsx*/" />);
+
+// @Filename: /b.js
+//// addListener("/*js*/");
 
-verify.completions({ marker: "", isNewIdentifierLocation: true, exact: ["drag", "dragenter"] });
+verify.completions({ marker: ["ts", "js"], isNewIdentifierLocation: true, exact: ["", "drag", "dragenter"] });
+verify.completions({ marker: "tsx", exact: ["", "drag", "dragenter"] });
 edit.insert("drag");
-verify.completions({ isNewIdentifierLocation: true, exact: ["drag", "dragenter"] });
+verify.completions({ isNewIdentifierLocation: true, exact: ["", "drag", "dragenter"] });