Fix #62738: Allow protected access with explicit 'this' parameters

[PaulyBearCoding]

Fixes #62738

The Bug

TypeScript incorrectly rejects this valid pattern:

class MyClass {
  protected myMethod() {}
}

class MyDerivedClass extends MyClass {
  static {
    this.prototype.myMethod = function(this: MyDerivedClass) {
      MyClass.prototype.myMethod.call(this); // ❌ Error TS2446
    }
  }
}

Error:

Property 'myMethod' is protected and only accessible through an instance of
class 'MyDerivedClass'. This is an instance of class 'MyClass'.(2446)

Why this should work:

• Function has explicit this: MyDerivedClass parameter
• MyDerivedClass extends MyClass
• TypeScript validates explicit this at call sites
• Pattern is type-safe

Maintainer confirmed: @RyanCavanaugh commented: "This specific error seems wrong"

---

The Fix

Modified checkPropertyAccessibility() in src/compiler/checker.ts:

1. Check explicit this parameters first (for instance members only)

// For instance members, check explicit 'this' parameter first
if (!(flags & ModifierFlags.Static)) {
    enclosingClass = getEnclosingClassFromThisParameter(location);
    fromExplicitThis = !!enclosingClass;
}

// Then check class hierarchy
if (!enclosingClass) {
    enclosingClass = forEachEnclosingClass(location, ...);
}

2. Allow bidirectional type relationship when explicit this present

// Standard: containingType must be subclass of enclosingClass
// New: OR enclosingClass is subclass of containingType (when explicit 'this')
if (!(hasBaseType(containingType, enclosingClass) ||
      (fromExplicitThis && hasBaseType(enclosingClass, containingType)))) {
    error(...);
}

---

Why This Works

When you write function(this: DerivedClass), TypeScript already validates the type at call sites:

const fn = function(this: Derived) {
    Base.prototype.method.call(this);
};

fn.call(new Derived());  // ✅ Type-safe
fn.call(new Base());     // ❌ Compile error

The fix recognizes that if TypeScript already guarantees this is the correct type, then accessing base class protected members is safe.

---

Test Results

TypeScript's test suites:

conformance/classes: 3,732 passing
conformance/types: 5,076 passing
members/accessibility: 132 passing

Before fix:

$ tsc repro-62738.ts
repro-62738.ts(27,25): error TS2446

After fix:

$ tsc repro-62738.ts
# Compiles successfully

---

What Still Errors (Security Maintained)

// ❌ Unrelated class
class Unrelated {
    test() {
        const fn = function(this: Unrelated) {
            Base.prototype.method.call(this); // Error TS2445
        };
    }
}

// ❌ External access
const instance = new Derived();
instance.method(); // Error TS2445

// ❌ Static protected members
function fn(this: MyClass) {
    MyClass.staticProtected = 1; // Error TS2445
}

---

Files Changed

Modified:

• src/compiler/checker.ts (40 lines)

Added:

• tests/cases/conformance/classes/members/accessibility/protectedAccessViaExplicitThisParameter.ts
• Corresponding baseline files

---

Breaking Changes

None.