diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index c593da7a440ce..16594682a6368 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -109,6 +109,7 @@ namespace ts { getDeclaredTypeOfSymbol, getPropertiesOfType, getPropertyOfType: (type, name) => getPropertyOfType(type, escapeLeadingUnderscores(name)), + getTypeOfPropertyOfType: (type, name) => getTypeOfPropertyOfType(type, escapeLeadingUnderscores(name)), getIndexInfoOfType, getSignaturesOfType, getIndexTypeOfType, @@ -291,6 +292,7 @@ namespace ts { getNeverType: () => neverType, isSymbolAccessible, isArrayLikeType, + isTypeInvalidDueToUnionDiscriminant, getAllPossiblePropertiesOfTypes, getSuggestionForNonexistentProperty: (node, type) => getSuggestionForNonexistentProperty(node, type), getSuggestionForNonexistentSymbol: (location, name, meaning) => getSuggestionForNonexistentSymbol(location, escapeLeadingUnderscores(name), meaning), @@ -6746,6 +6748,18 @@ namespace ts { getPropertiesOfObjectType(type); } + function isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression): boolean { + return obj.properties.some(property => { + const name = property.name && getTextOfPropertyName(property.name); + const expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name); + if (expected && typeIsLiteralType(expected)) { + const actual = getTypeOfNode(property); + return !!actual && !isTypeIdenticalTo(actual, expected); + } + return false; + }); + } + function getAllPossiblePropertiesOfTypes(types: ReadonlyArray): Symbol[] { const unionType = getUnionType(types); if (!(unionType.flags & TypeFlags.Union)) { @@ -29011,4 +29025,8 @@ namespace ts { export const IntrinsicClassAttributes = "IntrinsicClassAttributes" as __String; // tslint:enable variable-name } + + function typeIsLiteralType(type: Type): type is LiteralType { + return !!(type.flags & TypeFlags.Literal); + } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 64ee4a28f2c34..8043826ddaad8 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2879,6 +2879,7 @@ namespace ts { getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; + /* @internal */ getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getSignaturesOfType(type: Type, kind: SignatureKind): ReadonlyArray; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; @@ -3046,6 +3047,11 @@ namespace ts { /* @internal */ getTypeCount(): number; /* @internal */ isArrayLikeType(type: Type): boolean; + /** + * True if `contextualType` should not be considered for completions because + * e.g. it specifies `kind: "a"` and obj has `kind: "b"`. + */ + /* @internal */ isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression): boolean; /** * For a union, will include a property if it's defined in *any* of the member types. * So for `{ a } | { b }`, this will include both `a` and `b`. diff --git a/src/services/completions.ts b/src/services/completions.ts index 535f6f4f745e4..4578f062abaa9 100644 --- a/src/services/completions.ts +++ b/src/services/completions.ts @@ -1105,7 +1105,7 @@ namespace ts.Completions { // each individual type has. This is because we're going to add all identifiers // anyways. So we might as well elevate the members that were at least part // of the individual types to a higher status since we know what they are. - symbols.push(...getPropertiesForCompletion(type, typeChecker, /*isForAccess*/ true)); + symbols.push(...getPropertiesForCompletion(type, typeChecker)); } else { for (const symbol of type.getApparentProperties()) { @@ -1225,7 +1225,7 @@ namespace ts.Completions { if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== SyntaxKind.SourceFile) { const thisType = typeChecker.tryGetThisTypeAt(scopeNode); if (thisType) { - for (const symbol of getPropertiesForCompletion(thisType, typeChecker, /*isForAccess*/ true)) { + for (const symbol of getPropertiesForCompletion(thisType, typeChecker)) { symbolToOriginInfoMap[getSymbolId(symbol)] = { type: "this-type" }; symbols.push(symbol); } @@ -1542,7 +1542,7 @@ namespace ts.Completions { const typeForObject = typeChecker.getContextualType(objectLikeContainer); if (!typeForObject) return GlobalsSearch.Fail; isNewIdentifierLocation = hasIndexSignature(typeForObject); - typeMembers = getPropertiesForCompletion(typeForObject, typeChecker, /*isForAccess*/ false); + typeMembers = getPropertiesForObjectExpression(typeForObject, objectLikeContainer, typeChecker); existingMembers = objectLikeContainer.properties; } else { @@ -2163,19 +2163,25 @@ namespace ts.Completions { return jsdoc && jsdoc.tags && (rangeContainsPosition(jsdoc, position) ? findLast(jsdoc.tags, tag => tag.pos < position) : undefined); } + function getPropertiesForObjectExpression(contextualType: Type, obj: ObjectLiteralExpression, checker: TypeChecker): Symbol[] { + return contextualType.isUnion() + ? checker.getAllPossiblePropertiesOfTypes(contextualType.types.filter(memberType => + // If we're providing completions for an object literal, skip primitive, array-like, or callable types since those shouldn't be implemented by object literals. + !(memberType.flags & TypeFlags.Primitive || + checker.isArrayLikeType(memberType) || + typeHasCallOrConstructSignatures(memberType, checker) || + checker.isTypeInvalidDueToUnionDiscriminant(memberType, obj)))) + : contextualType.getApparentProperties(); + } + /** * Gets all properties on a type, but if that type is a union of several types, * excludes array-like types or callable/constructable types. */ - function getPropertiesForCompletion(type: Type, checker: TypeChecker, isForAccess: boolean): Symbol[] { - if (!(type.isUnion())) { - return Debug.assertEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined"); - } - - // If we're providing completions for an object literal, skip primitive, array-like, or callable types since those shouldn't be implemented by object literals. - const filteredTypes = isForAccess ? type.types : type.types.filter(memberType => - !(memberType.flags & TypeFlags.Primitive || checker.isArrayLikeType(memberType) || typeHasCallOrConstructSignatures(memberType, checker))); - return Debug.assertEachDefined(checker.getAllPossiblePropertiesOfTypes(filteredTypes), "getAllPossiblePropertiesOfTypes() should all be defined"); + function getPropertiesForCompletion(type: Type, checker: TypeChecker): Symbol[] { + return type.isUnion() + ? Debug.assertEachDefined(checker.getAllPossiblePropertiesOfTypes(type.types), "getAllPossiblePropertiesOfTypes() should all be defined") + : Debug.assertEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined"); } /** diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index a0624e4f087ed..47b8c7e45560b 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -2566,6 +2566,7 @@ declare namespace ts { getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; + getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getSignaturesOfType(type: Type, kind: SignatureKind): ReadonlyArray; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; @@ -2708,6 +2709,11 @@ declare namespace ts { getSymbolCount(): number; getTypeCount(): number; isArrayLikeType(type: Type): boolean; + /** + * True if `contextualType` should not be considered for completions because + * e.g. it specifies `kind: "a"` and obj has `kind: "b"`. + */ + isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression): boolean; /** * For a union, will include a property if it's defined in *any* of the member types. * So for `{ a } | { b }`, this will include both `a` and `b`. diff --git a/tests/cases/fourslash/completionsDiscriminatedUnion.ts b/tests/cases/fourslash/completionsDiscriminatedUnion.ts new file mode 100644 index 0000000000000..ff6346e909f09 --- /dev/null +++ b/tests/cases/fourslash/completionsDiscriminatedUnion.ts @@ -0,0 +1,7 @@ +/// + +////interface A { kind: "a"; a: number; } +////interface B { kind: "b"; b: number; } +////const c: A | B = { kind: "a", /**/ }; + +verify.completions({ marker: "", exact: ["a"] });