fix: report error for private property access on generic intersection types

[hesam-oxe]

When two classes have conflicting private properties, accessing them
via indexed access on their intersection should report an error,
consistent with union behavior.

Root Cause

getIndexedAccessTypeOrUndefined did not check for conflicting
private properties in intersection types before resolving indexed access.

Fix

Added check after getReducedType() using existing isConflictingPrivateProperty
helper to detect private property conflicts and report
Property_0_is_private_and_only_accessible_within_class_1.

Before

type Z<T extends A & B> = T["a"];         // no error ❌
type Z3<T extends A, T2 extends B> = (T & T2)["a"];  // no error ❌

After

type Z<T extends A & B> = T["a"];         // Error ✅
type Z3<T extends A, T2 extends B> = (T & T2)["a"];  // Error ✅

Related

• PR Reduce intersections with conflicting privates, elaborate on reasons #37762: Original intersection reduction logic
• Issue Missing error about inability to access conflicting private properties on generic types involving intersections #62294

Closes #62294

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

Adds a type-checking error when using indexed access (T["key"]) on intersection types that contain conflicting private properties, preventing private members from being accessed through the type system.

Changes:

• Detect conflicting private properties on intersection object types during indexed access.
• Report an existing “private and only accessible within class” diagnostic for the conflicting property.
• Bail out of indexed-access resolution when such a conflict is found.

Comments suppressed due to low confidence (2)

src/compiler/checker.ts:1

• Returning undefined is currently gated on accessNode, which means the checker will continue resolving the indexed access when accessNode is absent (e.g., in non-error-reporting/type-query contexts), potentially producing a type that still reflects access to conflicting private members. Consider returning undefined whenever conflictingPrivate is found, and only conditionally emitting error(...) when accessNode is present.
  src/compiler/checker.ts:1
• The non-null assertion on getDeclaringClass(conflictingPrivate)! makes this path brittle if isConflictingPrivateProperty can ever match a symbol without a declaring class (e.g., unusual synthetic symbols). Prefer guarding and producing a safe fallback (or skipping the diagnostic parameter) instead of asserting, so this error-reporting path can't crash the checker.

[hesam-oxe]

@microsoft-github-policy-service agree

[RyanCavanaugh]

https://github.com/microsoft/TypeScript/blob/main/CONTRIBUTING.md#notes-on-contributing

[hesam-oxe]

@RyanCavanaugh Ah, I missed the memo about typescript-go!
Thanks for the pointer.

I'll re-implement this fix in the typescript-go repo instead.

Quick question: is the same getIndexedAccessTypeOrUndefined
logic in the Go codebase, or has the checker been restructured?
Just want to know where to start looking. 🙏