fix: error on private property access in 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.

This is the Go implementation of the fix originally submitted to
microsoft/TypeScript#63548 (closed — JS codebase is winding down).

Root Cause

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

Fix

Added check after getReducedType() to detect conflicting private
properties 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

• Missing error about inability to access conflicting private properties on generic types involving intersections TypeScript#62294 (original issue)
• fix: report error for private property access on generic intersection types TypeScript#63548 (JS version — closed)
• PR #37762 (original intersection reduction logic)

Closes microsoft/TypeScript#62294

[Copilot]

Pull request overview

Note

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

Adds a diagnostic guard to prevent indexed-access type queries from succeeding on intersection types that contain conflicting private properties.

Changes:

• Detects intersection types with conflicting private properties during indexed access type computation.
• Emits Property_0_is_private_and_only_accessible_within_class_1 when an indexed access targets such a property.
• Aborts the indexed access type resolution by returning nil in that scenario.

Comments suppressed due to low confidence (2)

internal/checker/checker.go:1

• The new guard only triggers when accessNode != nil, which means the checker may still compute and return an indexed-access type for an intersection containing a conflicting private property when accessNode is nil. That contradicts the comment ('we shouldn't be able to access those properties') and can lead to inconsistent behavior depending on call site. Consider separating the concerns: always prevent the access (e.g., return nil or an appropriate failure type) when isConflictingPrivateProperty(prop) is true, and conditionally emit the diagnostic only when accessNode != nil.
  internal/checker/checker.go:1
• There is trailing whitespace after the comma at the end of the c.error(..., line. This will typically fail whitespace-focused linters and is easy to fix by removing the trailing space (and/or letting gofmt format the call).

[RyanCavanaugh]

This unconditionally errors if you try to use an indexed access type on an intersection of two classes with conflicting private members, which is not correct.