Fix completions of optional properties in generic positions

src/compiler/checker.ts

@@ -174,12 +174,6 @@ namespace ts {
         IsForSignatureHelp = 1 << 4,    // Call resolution for purposes of signature help
     }
 
-    const enum ContextFlags {
-        None = 0,
-        Signature = 1 << 0,  // Obtaining contextual signature
-        NoConstraints = 1 << 1,  // Don't obtain type variable constraints
-    }
-
     const enum AccessFlags {
         None = 0,
         NoIndexSignatures = 1 << 0,
@@ -454,9 +448,9 @@ namespace ts {
             },
             getAugmentedPropertiesOfType,
             getRootSymbols,
-            getContextualType: nodeIn => {
+            getContextualType: (nodeIn: Expression, contextFlags?: ContextFlags) => {
                 const node = getParseTreeNode(nodeIn, isExpression);
-                return node ? getContextualType(node) : undefined;
+                return node ? getContextualType(node, contextFlags) : undefined;
             },
             getContextualTypeForObjectLiteralElement: nodeIn => {
                 const node = getParseTreeNode(nodeIn, isObjectLiteralElementLike);
@@ -20887,19 +20881,23 @@ namespace ts {
         }
 
         // In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter.
-        function getContextualTypeForArgument(callTarget: CallLikeExpression, arg: Expression): Type | undefined {
+        function getContextualTypeForArgument(callTarget: CallLikeExpression, arg: Expression, contextFlags?: ContextFlags): Type | undefined {
             const args = getEffectiveCallArguments(callTarget);
             const argIndex = args.indexOf(arg); // -1 for e.g. the expression of a CallExpression, or the tag of a TaggedTemplateExpression
-            return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex);
+            return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex, contextFlags);
         }
 
-        function getContextualTypeForArgumentAtIndex(callTarget: CallLikeExpression, argIndex: number): Type {
+        function getContextualTypeForArgumentAtIndex(callTarget: CallLikeExpression, argIndex: number, contextFlags?: ContextFlags): Type {
             // If we're already in the process of resolving the given signature, don't resolve again as
             // that could cause infinite recursion. Instead, return anySignature.
-            const signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
+            const signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget, /*candidatesOutArray*/ undefined, /*checkMode*/ undefined);
             if (isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
                 return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
             }
+            if (contextFlags && contextFlags & ContextFlags.Completion && signature.target) {
+                const baseSiganture = getBaseSignature(signature.target);
+                return intersectTypes(getTypeAtPosition(signature, argIndex), getTypeAtPosition(baseSiganture, argIndex));
+            }
             return getTypeAtPosition(signature, argIndex);
         }
 
@@ -21291,7 +21289,7 @@ namespace ts {
                     }
                     /* falls through */
                 case SyntaxKind.NewExpression:
-                    return getContextualTypeForArgument(<CallExpression | NewExpression>parent, node);
+                    return getContextualTypeForArgument(<CallExpression | NewExpression>parent, node, contextFlags);
                 case SyntaxKind.TypeAssertionExpression:
                 case SyntaxKind.AsExpression:
                     return isConstTypeReference((<AssertionExpression>parent).type) ? undefined : getTypeFromTypeNode((<AssertionExpression>parent).type);
@@ -24381,7 +24379,7 @@ namespace ts {
                 return resolveErrorCall(node);
             }
 
-            return resolveCall(node, callSignatures, candidatesOutArray, checkMode, isOptional);
+            return resolveCall(node, callSignatures, candidatesOutArray, checkMode, isOptional, /*fallbackError*/ undefined);
         }
 
         function isGenericFunctionReturningFunction(signature: Signature) {
@@ -24452,7 +24450,7 @@ namespace ts {
                     return resolveErrorCall(node);
                 }
 
-                return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, /*isOptional*/ false);
+                return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, /*isOptional*/ false, /*fallbackError*/ undefined);
             }
 
             // If expressionType's apparent type is an object type with no construct signatures but
@@ -24461,7 +24459,7 @@ namespace ts {
             // operation is Any. It is an error to have a Void this type.
             const callSignatures = getSignaturesOfType(expressionType, SignatureKind.Call);
             if (callSignatures.length) {
-                const signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, /*isOptional*/ false);
+                const signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, /*isOptional*/ false, /*fallbackError*/ undefined);
                 if (!noImplicitAny) {
                     if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) {
                         error(node, Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);

src/compiler/types.ts

@@ -3365,8 +3365,10 @@ namespace ts {
 
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];
+
         getRootSymbols(symbol: Symbol): readonly Symbol[];
         getContextualType(node: Expression): Type | undefined;
+        /* @internal */ getContextualType(node: Expression, contextFlags?: ContextFlags): Type | undefined; // eslint-disable-line @typescript-eslint/unified-signatures
         /* @internal */ getContextualTypeForObjectLiteralElement(element: ObjectLiteralElementLike): Type | undefined;
         /* @internal */ getContextualTypeForArgumentAtIndex(call: CallLikeExpression, argIndex: number): Type | undefined;
         /* @internal */ getContextualTypeForJsxAttribute(attribute: JsxAttribute | JsxSpreadAttribute): Type | undefined;
@@ -3526,6 +3528,14 @@ namespace ts {
         Subtype
     }
 
+    /* @internal */
+    export const enum ContextFlags {
+        None          = 0,
+        Signature     = 1 << 0, // Obtaining contextual signature
+        NoConstraints = 1 << 1, // Don't obtain type variable constraints
+        Completion    = 1 << 2, // Obtaining constraint type for completion
+    }
+
     // NOTE: If modifying this enum, must modify `TypeFormatFlags` too!
     export const enum NodeBuilderFlags {
         None                                    = 0,

src/services/completions.ts

@@ -1760,7 +1760,7 @@ namespace ts.Completions {
             let existingMembers: readonly Declaration[] | undefined;
 
             if (objectLikeContainer.kind === SyntaxKind.ObjectLiteralExpression) {
-                const typeForObject = typeChecker.getContextualType(objectLikeContainer);
+                const typeForObject = typeChecker.getContextualType(objectLikeContainer, ContextFlags.Completion);
                 if (!typeForObject) return GlobalsSearch.Fail;
                 isNewIdentifierLocation = hasIndexSignature(typeForObject);
                 typeMembers = getPropertiesForObjectExpression(typeForObject, objectLikeContainer, typeChecker);

tests/cases/fourslash/completionsWithGenericStringLiteral.ts

@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// declare function get<T, K extends keyof T>(obj: T, key: K): T[K];
+//// get({ hello: 123, world: 456 }, "/**/");
+
+verify.completions({
+  marker: "",
+  includes: ['hello', 'world']
+});
+

tests/cases/fourslash/completionsWithOptionalPropertiesGeneric.ts

@@ -0,0 +1,19 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// interface MyOptions {
+////     hello?: boolean;
+////     world?: boolean;
+//// }
+//// declare function bar<T extends MyOptions>(options?: Partial<T>): void;
+//// bar({ hello, /*1*/ });
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'world'
+    },
+  ]
+})

tests/cases/fourslash/completionsWithOptionalPropertiesGenericConstructor.ts

@@ -0,0 +1,27 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// interface Options {
+////     someFunction?: () => string
+////     anotherFunction?: () => string
+//// }
+//// 
+//// export class Clazz<T extends Options> {
+////     constructor(public a: T) {}
+//// }
+//// 
+//// new Clazz({ /*1*/ })
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'someFunction'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'anotherFunction'
+    },
+  ]
+})

tests/cases/fourslash/completionsWithOptionalPropertiesGenericDeep.ts

@@ -0,0 +1,23 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// interface DeepOptions {
+////     another?: boolean;
+//// }
+//// interface MyOptions {
+////     hello?: boolean;
+////     world?: boolean;
+////     deep?: DeepOptions
+//// }
+//// declare function bar<T extends MyOptions>(options?: Partial<T>): void;
+//// bar({ deep: {/*1*/} });
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'another'
+    },
+  ]
+})

tests/cases/fourslash/completionsWithOptionalPropertiesGenericPartial.ts

@@ -0,0 +1,33 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// interface Foo {
+////     a_a: boolean;
+////     a_b: boolean;
+////     a_c: boolean;
+////     b_a: boolean;
+//// }
+//// function partialFoo<T extends Partial<Foo>>(t: T) {return t}
+//// partialFoo({ /*1*/ });
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'a_a'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'a_b'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'a_c'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'b_a'
+    },
+  ]
+})

tests/cases/fourslash/completionsWithOptionalPropertiesGenericPartial2.ts

@@ -0,0 +1,22 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+//// interface Foo {
+////     a: boolean;
+//// }
+//// function partialFoo<T extends Partial<Foo>>(x: T, y: T) {return t}
+//// partialFoo({ a: true, b: true }, { /*1*/ });
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'a'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'b'
+    }
+  ]
+})

tests/cases/fourslash/completionsWithOptionalPropertiesGenericPartial3.ts

@@ -0,0 +1,29 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+////interface Foo {
+////  a: boolean;
+////}
+////function partialFoo<T extends Partial<Foo>>(x: T, y: T extends { b?: boolean } ? T & { c: true } : T) {
+////  return x;
+////}
+////
+////partialFoo({ a: true, b: true }, { /*1*/ });
+
+
+verify.completions({
+  marker: '1',
+  includes: [
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'a'
+    },
+    {
+      sortText: completion.SortText.OptionalMember,
+      name: 'b'
+    },
+    {
+      name: 'c'
+    }
+  ]
+})