[Cherry-pick] Properly handle private/protected members in unions of object types (…

src/compiler/checker.ts

@@ -10473,10 +10473,10 @@ namespace ts {
         }
 
         function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: __String): Symbol | undefined {
-            const propSet = createMap<Symbol>();
+            let singleProp: Symbol | undefined;
+            let propSet: Map<Symbol> | undefined;
             let indexTypes: Type[] | undefined;
             const isUnion = containingType.flags & TypeFlags.Union;
-            const excludeModifiers = isUnion ? ModifierFlags.NonPublicAccessibilityModifier : 0;
             // Flags we want to propagate to the result if they exist in all source symbols
             let optionalFlag = isUnion ? SymbolFlags.None : SymbolFlags.Optional;
             let syntheticFlag = CheckFlags.SyntheticMethod;
@@ -10486,16 +10486,25 @@ namespace ts {
                 if (!(type === errorType || type.flags & TypeFlags.Never)) {
                     const prop = getPropertyOfType(type, name);
                     const modifiers = prop ? getDeclarationModifierFlagsFromSymbol(prop) : 0;
-                    if (prop && !(modifiers & excludeModifiers)) {
+                    if (prop) {
                         if (isUnion) {
                             optionalFlag |= (prop.flags & SymbolFlags.Optional);
                         }
                         else {
                             optionalFlag &= prop.flags;
                         }
-                        const id = "" + getSymbolId(prop);
-                        if (!propSet.has(id)) {
-                            propSet.set(id, prop);
+                        if (!singleProp) {
+                            singleProp = prop;
+                        }
+                        else if (prop !== singleProp) {
+                            if (!propSet) {
+                                propSet = createMap<Symbol>();
+                                propSet.set("" + getSymbolId(singleProp), singleProp);
+                            }
+                            const id = "" + getSymbolId(prop);
+                            if (!propSet.has(id)) {
+                                propSet.set(id, prop);
+                            }
                         }
                         checkFlags |= (isReadonlySymbol(prop) ? CheckFlags.Readonly : 0) |
                             (!(modifiers & ModifierFlags.NonPublicAccessibilityModifier) ? CheckFlags.ContainsPublic : 0) |
@@ -10522,13 +10531,15 @@ namespace ts {
                     }
                 }
             }
-            if (!propSet.size) {
+            if (!singleProp || isUnion && (propSet || checkFlags & CheckFlags.Partial) && checkFlags & (CheckFlags.ContainsPrivate | CheckFlags.ContainsProtected)) {
+                // No property was found, or, in a union, a property has a private or protected declaration in one
+                // constituent, but is missing or has a different declaration in another constituent.
                 return undefined;
             }
-            const props = arrayFrom(propSet.values());
-            if (props.length === 1 && !(checkFlags & CheckFlags.ReadPartial) && !indexTypes) {
-                return props[0];
+            if (!propSet && !(checkFlags & CheckFlags.ReadPartial) && !indexTypes) {
+                return singleProp;
             }
+            const props = propSet ? arrayFrom(propSet.values()) : [singleProp];
             let declarations: Declaration[] | undefined;
             let firstType: Type | undefined;
             let nameType: Type | undefined;

tests/baselines/reference/privatePropertyInUnion.js

@@ -0,0 +1,24 @@
+//// [privatePropertyInUnion.ts]
+// Repro from #38236
+
+type Type = string | object;
+
+class SyncableObject {
+  private foo: unknown;
+}
+
+interface SyncableRef<T extends ISyncableObject> {}
+
+interface ISyncableObject<T = object> extends SyncableObject {}
+
+type __ValueDescriptorType<T extends string | object> = T extends ISyncableObject ? SyncableRef<T> : T;
+
+
+//// [privatePropertyInUnion.js]
+"use strict";
+// Repro from #38236
+var SyncableObject = /** @class */ (function () {
+    function SyncableObject() {
+    }
+    return SyncableObject;
+}());

tests/baselines/reference/privatePropertyInUnion.symbols

@@ -0,0 +1,32 @@
+=== tests/cases/compiler/privatePropertyInUnion.ts ===
+// Repro from #38236
+
+type Type = string | object;
+>Type : Symbol(Type, Decl(privatePropertyInUnion.ts, 0, 0))
+
+class SyncableObject {
+>SyncableObject : Symbol(SyncableObject, Decl(privatePropertyInUnion.ts, 2, 28))
+
+  private foo: unknown;
+>foo : Symbol(SyncableObject.foo, Decl(privatePropertyInUnion.ts, 4, 22))
+}
+
+interface SyncableRef<T extends ISyncableObject> {}
+>SyncableRef : Symbol(SyncableRef, Decl(privatePropertyInUnion.ts, 6, 1))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 8, 22))
+>ISyncableObject : Symbol(ISyncableObject, Decl(privatePropertyInUnion.ts, 8, 51))
+
+interface ISyncableObject<T = object> extends SyncableObject {}
+>ISyncableObject : Symbol(ISyncableObject, Decl(privatePropertyInUnion.ts, 8, 51))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 10, 26))
+>SyncableObject : Symbol(SyncableObject, Decl(privatePropertyInUnion.ts, 2, 28))
+
+type __ValueDescriptorType<T extends string | object> = T extends ISyncableObject ? SyncableRef<T> : T;
+>__ValueDescriptorType : Symbol(__ValueDescriptorType, Decl(privatePropertyInUnion.ts, 10, 63))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 12, 27))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 12, 27))
+>ISyncableObject : Symbol(ISyncableObject, Decl(privatePropertyInUnion.ts, 8, 51))
+>SyncableRef : Symbol(SyncableRef, Decl(privatePropertyInUnion.ts, 6, 1))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 12, 27))
+>T : Symbol(T, Decl(privatePropertyInUnion.ts, 12, 27))
+

tests/baselines/reference/privatePropertyInUnion.types

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/privatePropertyInUnion.ts ===
+// Repro from #38236
+
+type Type = string | object;
+>Type : string | object
+
+class SyncableObject {
+>SyncableObject : SyncableObject
+
+  private foo: unknown;
+>foo : unknown
+}
+
+interface SyncableRef<T extends ISyncableObject> {}
+
+interface ISyncableObject<T = object> extends SyncableObject {}
+
+type __ValueDescriptorType<T extends string | object> = T extends ISyncableObject ? SyncableRef<T> : T;
+>__ValueDescriptorType : __ValueDescriptorType<T>
+

tests/cases/compiler/privatePropertyInUnion.ts

@@ -0,0 +1,15 @@
+// @strict: true
+
+// Repro from #38236
+
+type Type = string | object;
+
+class SyncableObject {
+  private foo: unknown;
+}
+
+interface SyncableRef<T extends ISyncableObject> {}
+
+interface ISyncableObject<T = object> extends SyncableObject {}
+
+type __ValueDescriptorType<T extends string | object> = T extends ISyncableObject ? SyncableRef<T> : T;