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);
  if (isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
  return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
  }
+ if (contextFlags && contextFlags & ContextFlags.Completion && signature.target) {
+ const baseSignature = getBaseSignature(signature.target);
+ return intersectTypes(getTypeAtPosition(signature, argIndex), getTypeAtPosition(baseSignature, 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);

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/harness/fourslash.ts

@@ -775,7 +775,9 @@ namespace FourSlash {
  private verifyCompletionsWorker(options: FourSlashInterface.VerifyCompletionsOptions): void {
  const actualCompletions = this.getCompletionListAtCaret({ ...options.preferences, triggerCharacter: options.triggerCharacter })!;
  if (!actualCompletions) {
- if (ts.hasProperty(options, "exact") && options.exact === undefined) return;
+ if (ts.hasProperty(options, "exact") && (options.exact === undefined || ts.isArray(options.exact) && !options.exact.length)) {
+ return;
+ }
  this.raiseError(`No completions at position '${this.currentCaretPosition}'.`);
  }
 

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/completionsGenericUnconstrained.ts

@@ -0,0 +1,14 @@
+/// <reference path="fourslash.ts" />
+// @strict: true
+
+////function f<T>(x: T) {
+//// return x;
+////}
+////
+////f({ /**/ });
+
+
+verify.completions({
+ marker: "",
+ exact: []
+});

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'
+ }
+ ]
+})