Slightly better I guess

Author: andrewbranch

src/compiler/checker.ts

@@ -20981,18 +20981,9 @@ namespace ts {
             if (isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
                 return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
             }
-            if (contextFlags && contextFlags & ContextFlags.Completion && signature.target) {
+            if (contextFlags && contextFlags & ContextFlags.BaseConstraint && signature.target && !tryCast(callTarget, hasTypeArguments)?.typeArguments) {
                 const baseSignature = getBaseSignature(signature.target);
-                // Only consider the type from the base signature for completions
-                // if it actually contributes something. The type from the contextually
-                // instantiated signature is the _real_ type anyway, so we should never
-                // let the base type _remove_ completions from the list.
-                const baseArgumentType = filterType(
-                    getTypeAtPosition(baseSignature, argIndex),
-                    t => !(t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.IndexedAccess)));
-                if (!(baseArgumentType.flags & TypeFlags.Never)) {
-                    return intersectTypes(getTypeAtPosition(signature, argIndex), baseArgumentType);
-                }
+                return getTypeAtPosition(baseSignature, argIndex);
             }
             return getTypeAtPosition(signature, argIndex);
         }

src/compiler/types.ts

@@ -708,6 +708,13 @@ namespace ts {
         | JSDocOptionalType
         | JSDocVariadicType;
 
+    export type HasTypeArguments =
+        | CallExpression
+        | NewExpression
+        | TaggedTemplateExpression
+        | JsxOpeningElement
+        | JsxSelfClosingElement;
+
     export type HasInitializer =
         | HasExpressionInitializer
         | ForStatement
@@ -3535,10 +3542,10 @@ namespace ts {
 
     /* @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
+        None           = 0,
+        Signature      = 1 << 0, // Obtaining contextual signature
+        NoConstraints  = 1 << 1, // Don't obtain type variable constraints
+        BaseConstraint = 1 << 2, // Use base constraint type for completions
     }
 
     // NOTE: If modifying this enum, must modify `TypeFormatFlags` too!

src/compiler/utilities.ts

@@ -7295,6 +7295,15 @@ namespace ts {
         return !!(node as HasType).type;
     }
 
+    /** @internal */
+    export function hasTypeArguments(node: Node): node is HasTypeArguments {
+        return node.kind === SyntaxKind.CallExpression
+            || node.kind === SyntaxKind.NewExpression
+            || node.kind === SyntaxKind.TaggedTemplateExpression
+            || node.kind === SyntaxKind.JsxOpeningElement
+            || node.kind === SyntaxKind.JsxSelfClosingElement;
+    }
+
     /** True if has initializer node attached to it. */
     /* @internal */
     export function hasInitializer(node: Node): node is HasInitializer {

src/services/completions.ts

@@ -1273,7 +1273,7 @@ namespace ts.Completions {
             // Cursor is inside a JSX self-closing element or opening element
             const attrsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes);
             if (!attrsType) return GlobalsSearch.Continue;
-            symbols = filterJsxAttributes(getPropertiesForObjectExpression(attrsType, jsxContainer!.attributes, typeChecker), jsxContainer!.attributes.properties);
+            symbols = filterJsxAttributes(getPropertiesForObjectExpression(attrsType, /*baseType*/ undefined, jsxContainer!.attributes, typeChecker), jsxContainer!.attributes.properties);
             setSortTextToOptionalMember();
             completionKind = CompletionKind.MemberLike;
             isNewIdentifierLocation = false;
@@ -1780,10 +1780,11 @@ namespace ts.Completions {
             let existingMembers: readonly Declaration[] | undefined;
 
             if (objectLikeContainer.kind === SyntaxKind.ObjectLiteralExpression) {
-                const typeForObject = typeChecker.getContextualType(objectLikeContainer, ContextFlags.Completion);
-                if (!typeForObject) return GlobalsSearch.Fail;
-                isNewIdentifierLocation = hasIndexSignature(typeForObject);
-                typeMembers = getPropertiesForObjectExpression(typeForObject, objectLikeContainer, typeChecker);
+                const instantiatedType = typeChecker.getContextualType(objectLikeContainer);
+                const baseType = instantiatedType && typeChecker.getContextualType(objectLikeContainer, ContextFlags.BaseConstraint);
+                if (!instantiatedType || !baseType) return GlobalsSearch.Fail;
+                isNewIdentifierLocation = hasIndexSignature(instantiatedType || baseType);
+                typeMembers = getPropertiesForObjectExpression(instantiatedType, baseType, objectLikeContainer, typeChecker);
                 existingMembers = objectLikeContainer.properties;
             }
             else {
@@ -2514,15 +2515,19 @@ namespace ts.Completions {
         return jsdoc && jsdoc.tags && (rangeContainsPosition(jsdoc, position) ? findLast(jsdoc.tags, tag => tag.pos < position) : undefined);
     }
 
-    function getPropertiesForObjectExpression(contextualType: Type, obj: ObjectLiteralExpression | JsxAttributes, checker: TypeChecker): Symbol[] {
-        return contextualType.isUnion()
-            ? checker.getAllPossiblePropertiesOfTypes(contextualType.types.filter(memberType =>
+    function getPropertiesForObjectExpression(contextualType: Type, baseConstrainedType: Type | undefined, obj: ObjectLiteralExpression | JsxAttributes, checker: TypeChecker): Symbol[] {
+        const type = baseConstrainedType && !(baseConstrainedType.flags & TypeFlags.AnyOrUnknown)
+            ? checker.getUnionType([contextualType, baseConstrainedType])
+            : contextualType;
+
+        return type.isUnion()
+            ? checker.getAllPossiblePropertiesOfTypes(type.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();
+            : type.getApparentProperties();
     }
 
     /**

tests/cases/fourslash/completionsConditionalMember.ts

@@ -0,0 +1,22 @@
+/// <reference path="fourslash.ts" />
+
+////declare function f<T extends string>(
+////  p: { a: T extends 'foo' ? { x: string } : { y: string } }
+////): void;
+////
+////f<'foo'>({ a: { /*1*/ } });
+////f<string>({ a: { /*2*/ } });
+
+verify.completions({
+  marker: '1',
+  exact: [{
+    name: 'x'
+  }]
+});
+
+verify.completions({
+  marker: '2',
+  exact: [{
+    name: 'y'
+  }]
+});