feat(44888): omit completions in an object expression with an instantiated class type

Author: a-tarasyuk

src/services/completions.ts

@@ -2157,7 +2157,7 @@ namespace ts.Completions {
                 const hasStringIndexType = (completionsType || instantiatedType).getStringIndexType();
                 const hasNumberIndextype = (completionsType || instantiatedType).getNumberIndexType();
                 isNewIdentifierLocation = !!hasStringIndexType || !!hasNumberIndextype;
-                typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker);
+                typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker) || emptyArray;
                 existingMembers = objectLikeContainer.properties;
 
                 if (typeMembers.length === 0) {
@@ -3033,15 +3033,11 @@ namespace ts.Completions {
             : contextualType;
 
         const properties = 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))))
+            ? checker.getAllPossiblePropertiesOfTypes(filter(type.types, memberType => isApparentType(memberType, obj, checker)))
             : type.getApparentProperties();
 
-        return hasCompletionsType ? properties.filter(hasDeclarationOtherThanSelf) : properties;
+        return type.isClass() && containsHiddenProps(properties) ? [] :
+            hasCompletionsType ? filter(properties, hasDeclarationOtherThanSelf) : properties;
 
         // Filter out members whose only declaration is the object literal itself to avoid
         // self-fulfilling completions like:
@@ -3053,6 +3049,18 @@ namespace ts.Completions {
         }
     }
 
+    function isApparentType(type: Type, node: ObjectLiteralExpression | JsxAttributes, checker: TypeChecker) {
+        return !(type.flags & TypeFlags.Primitive
+            || checker.isArrayLikeType(type)
+            || checker.isTypeInvalidDueToUnionDiscriminant(type, node)
+            || typeHasCallOrConstructSignatures(type, checker)
+            || type.isClass() && containsHiddenProps(type.getApparentProperties()));
+    }
+
+    function containsHiddenProps(props: Symbol[]) {
+        return some(props, p => !!(getDeclarationModifierFlagsFromSymbol(p) & ModifierFlags.NonPublicAccessibilityModifier));
+    }
+
     /**
      * Gets all properties on a type, but if that type is a union of several types,
      * excludes array-like types or callable/constructable types.

tests/cases/fourslash/completionInsideObjectLiteralExpressionWithInstantiatedClassType.ts

@@ -0,0 +1,38 @@
+/// <reference path="fourslash.ts" />
+
+////class C1 {
+////    public a: string;
+////    protected b: string;
+////    private c: string;
+////
+////    constructor(a: string, b = "", c = "") {
+////        this.a = a;
+////        this.b = b;
+////        this.c = c;
+////    }
+////}
+////class C2 {
+////    public a: string;
+////    constructor(a: string) {
+////        this.a = a;
+////    }
+////}
+////function f1(foo: C1 | C2 | { d: number }) {}
+////f1({ /*1*/ });
+
+////function f2(foo: C1 | C2) {}
+////f2({ /*2*/ });
+////
+////function f3(foo: C2) {}
+////f3({ /*3*/ });
+
+verify.completions({
+    marker: "1",
+    exact: ["a", "d"],
+}, {
+    marker: "2",
+    exact: ["a"]
+}, {
+    marker: "3",
+    exact: ["a"]
+});