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

src/compiler/checker.ts

@@ -34451,24 +34451,40 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             return true;
         }
 
-        // Find the first enclosing class that has the declaring classes of the protected constituents
-        // of the property as base classes
-        let enclosingClass = forEachEnclosingClass(location, enclosingDeclaration => {
-            const enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfDeclaration(enclosingDeclaration)) as InterfaceType;
-            return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
-        });
-        // A protected property is accessible if the property is within the declaring class or classes derived from it
-        if (!enclosingClass) {
-            // allow PropertyAccessibility if context is in function with this parameter
-            // static member access is disallowed
+        // For instance members, first check for explicit 'this' parameter which takes precedence.
+        // For static members, only use enclosing class hierarchy (explicit 'this' doesn't apply to statics).
+        let enclosingClass: InterfaceType | undefined;
+        let fromExplicitThis = false;
+
+        if (!(flags & ModifierFlags.Static)) {
             enclosingClass = getEnclosingClassFromThisParameter(location);
+            fromExplicitThis = !!enclosingClass;
             enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
-            if (flags & ModifierFlags.Static || !enclosingClass) {
+        }
+
+        // If no explicit 'this' parameter (or static member), find the first enclosing class that has
+        // the declaring classes of the protected constituents of the property as base classes
+        if (!enclosingClass) {
+            fromExplicitThis = false;
+            enclosingClass = forEachEnclosingClass(location, enclosingDeclaration => {
+                const enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfDeclaration(enclosingDeclaration)) as InterfaceType;
+                return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
+            });
+        }
+
+        // A protected property is accessible if the property is within the declaring class or classes derived from it
+        if (!enclosingClass) {
+            if (flags & ModifierFlags.Static) {
                 if (errorNode) {
                     error(errorNode, Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType));
                 }
                 return false;
             }
+            // No enclosing class found at all
+            if (errorNode) {
+                error(errorNode, Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType));
+            }
+            return false;
         }
         // No further restrictions for static properties
         if (flags & ModifierFlags.Static) {
@@ -34478,7 +34494,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // get the original type -- represented as the type constraint of the 'this' type
             containingType = (containingType as TypeParameter).isThisType ? getConstraintOfTypeParameter(containingType as TypeParameter)! : getBaseConstraintOfType(containingType as TypeParameter)!; // TODO: GH#18217 Use a different variable that's allowed to be undefined
         }
-        if (!containingType || !hasBaseType(containingType, enclosingClass)) {
+        // Allow protected access if containingType is enclosingClass or its subclass (standard behavior).
+        // Also allow if enclosingClass came from explicit 'this' parameter and is a subclass of containingType.
+        // This handles cases like: BaseClass.prototype.method.call(this) where this: DerivedClass
+        if (!containingType || !(hasBaseType(containingType, enclosingClass) || (fromExplicitThis && hasBaseType(enclosingClass, containingType)))) {
             if (errorNode) {
                 error(errorNode, Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2, symbolToString(prop), typeToString(enclosingClass), typeToString(containingType));
             }

tests/baselines/reference/protectedAccessViaExplicitThisParameter.errors.txt

@@ -0,0 +1,60 @@
+protectedAccessViaExplicitThisParameter.ts(43,22): error TS2445: Property 'baseMethod' is protected and only accessible within class 'Base' and its subclasses.
+protectedAccessViaExplicitThisParameter.ts(50,10): error TS2445: Property 'baseMethod' is protected and only accessible within class 'Derived' and its subclasses.
+
+
+==== protectedAccessViaExplicitThisParameter.ts (2 errors) ====
+    // Accessing base class protected methods via explicit 'this' parameter
+    // Should compile when 'this' type is a derived class
+
+    class Base {
+      protected baseMethod() {
+        return "Base.baseMethod";
+      }
+    }
+
+    class Derived extends Base {
+      protected override baseMethod() {
+        return "Derived.baseMethod";
+      }
+
+      // Test case 1: Static block with explicit 'this' parameter
+      static {
+        this.prototype.baseMethod = function(this: Derived) {
+          Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+          return "override";
+        }
+      }
+
+      // Test case 2: Regular method with explicit 'this' parameter
+      testExplicitThis() {
+        const fn = function(this: Derived) {
+          Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+        };
+        fn.call(this);
+      }
+
+      // Test case 3: Should still error with wrong explicit 'this' type
+      testWrongExplicitThis() {
+        const fn = function(this: Base) {
+          Base.prototype.baseMethod.call(this); // Error: this: Base, not compatible
+        };
+      }
+    }
+
+    // Test case 4: Should error without derived relationship
+    class Unrelated {
+      testUnrelated() {
+        const fn = function(this: Unrelated) {
+          Base.prototype.baseMethod.call(this); // Error: Unrelated not related to Base
+                         ~~~~~~~~~~
+!!! error TS2445: Property 'baseMethod' is protected and only accessible within class 'Base' and its subclasses.
+        };
+      }
+    }
+
+    // Test case 5: Should still error for external access
+    const instance = new Derived();
+    instance.baseMethod(); // Error: external access to protected member
+             ~~~~~~~~~~
+!!! error TS2445: Property 'baseMethod' is protected and only accessible within class 'Derived' and its subclasses.
+

tests/baselines/reference/protectedAccessViaExplicitThisParameter.js

@@ -0,0 +1,100 @@
+//// [tests/cases/conformance/classes/members/accessibility/protectedAccessViaExplicitThisParameter.ts] ////
+
+//// [protectedAccessViaExplicitThisParameter.ts]
+// Accessing base class protected methods via explicit 'this' parameter
+// Should compile when 'this' type is a derived class
+
+class Base {
+  protected baseMethod() {
+    return "Base.baseMethod";
+  }
+}
+
+class Derived extends Base {
+  protected override baseMethod() {
+    return "Derived.baseMethod";
+  }
+
+  // Test case 1: Static block with explicit 'this' parameter
+  static {
+    this.prototype.baseMethod = function(this: Derived) {
+      Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+      return "override";
+    }
+  }
+
+  // Test case 2: Regular method with explicit 'this' parameter
+  testExplicitThis() {
+    const fn = function(this: Derived) {
+      Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+    };
+    fn.call(this);
+  }
+
+  // Test case 3: Should still error with wrong explicit 'this' type
+  testWrongExplicitThis() {
+    const fn = function(this: Base) {
+      Base.prototype.baseMethod.call(this); // Error: this: Base, not compatible
+    };
+  }
+}
+
+// Test case 4: Should error without derived relationship
+class Unrelated {
+  testUnrelated() {
+    const fn = function(this: Unrelated) {
+      Base.prototype.baseMethod.call(this); // Error: Unrelated not related to Base
+    };
+  }
+}
+
+// Test case 5: Should still error for external access
+const instance = new Derived();
+instance.baseMethod(); // Error: external access to protected member
+
+
+//// [protectedAccessViaExplicitThisParameter.js]
+"use strict";
+// Accessing base class protected methods via explicit 'this' parameter
+// Should compile when 'this' type is a derived class
+class Base {
+    baseMethod() {
+        return "Base.baseMethod";
+    }
+}
+class Derived extends Base {
+    baseMethod() {
+        return "Derived.baseMethod";
+    }
+    // Test case 1: Static block with explicit 'this' parameter
+    static {
+        this.prototype.baseMethod = function () {
+            Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+            return "override";
+        };
+    }
+    // Test case 2: Regular method with explicit 'this' parameter
+    testExplicitThis() {
+        const fn = function () {
+            Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+        };
+        fn.call(this);
+    }
+    // Test case 3: Should still error with wrong explicit 'this' type
+    testWrongExplicitThis() {
+        const fn = function () {
+            Base.prototype.baseMethod.call(this); // Error: this: Base, not compatible
+        };
+    }
+}
+// Test case 4: Should error without derived relationship
+class Unrelated {
+    testUnrelated() {
+        const fn = function () {
+            Base.prototype.baseMethod.call(this); // Error: Unrelated not related to Base
+        };
+    }
+}
+// Test case 5: Should still error for external access
+const instance = new Derived();
+instance.baseMethod(); // Error: external access to protected member

tests/baselines/reference/protectedAccessViaExplicitThisParameter.symbols

@@ -0,0 +1,137 @@
+//// [tests/cases/conformance/classes/members/accessibility/protectedAccessViaExplicitThisParameter.ts] ////
+
+=== protectedAccessViaExplicitThisParameter.ts ===
+// Accessing base class protected methods via explicit 'this' parameter
+// Should compile when 'this' type is a derived class
+
+class Base {
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+
+  protected baseMethod() {
+>baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+
+    return "Base.baseMethod";
+  }
+}
+
+class Derived extends Base {
+>Derived : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+
+  protected override baseMethod() {
+>baseMethod : Symbol(Derived.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 9, 28))
+
+    return "Derived.baseMethod";
+  }
+
+  // Test case 1: Static block with explicit 'this' parameter
+  static {
+    this.prototype.baseMethod = function(this: Derived) {
+>this.prototype.baseMethod : Symbol(Derived.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 9, 28))
+>this.prototype : Symbol(Derived.prototype)
+>this : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+>prototype : Symbol(Derived.prototype)
+>baseMethod : Symbol(Derived.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 9, 28))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 16, 41))
+>Derived : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+
+      Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+>Base.prototype.baseMethod.call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>Base.prototype.baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>Base.prototype : Symbol(Base.prototype)
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+>prototype : Symbol(Base.prototype)
+>baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 16, 41))
+
+      return "override";
+    }
+  }
+
+  // Test case 2: Regular method with explicit 'this' parameter
+  testExplicitThis() {
+>testExplicitThis : Symbol(Derived.testExplicitThis, Decl(protectedAccessViaExplicitThisParameter.ts, 20, 3))
+
+    const fn = function(this: Derived) {
+>fn : Symbol(fn, Decl(protectedAccessViaExplicitThisParameter.ts, 24, 9))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 24, 24))
+>Derived : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+
+      Base.prototype.baseMethod.call(this); // OK: explicit this: Derived
+>Base.prototype.baseMethod.call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>Base.prototype.baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>Base.prototype : Symbol(Base.prototype)
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+>prototype : Symbol(Base.prototype)
+>baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 24, 24))
+
+    };
+    fn.call(this);
+>fn.call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>fn : Symbol(fn, Decl(protectedAccessViaExplicitThisParameter.ts, 24, 9))
+>call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+  }
+
+  // Test case 3: Should still error with wrong explicit 'this' type
+  testWrongExplicitThis() {
+>testWrongExplicitThis : Symbol(Derived.testWrongExplicitThis, Decl(protectedAccessViaExplicitThisParameter.ts, 28, 3))
+
+    const fn = function(this: Base) {
+>fn : Symbol(fn, Decl(protectedAccessViaExplicitThisParameter.ts, 32, 9))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 32, 24))
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+
+      Base.prototype.baseMethod.call(this); // Error: this: Base, not compatible
+>Base.prototype.baseMethod.call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>Base.prototype.baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>Base.prototype : Symbol(Base.prototype)
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+>prototype : Symbol(Base.prototype)
+>baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 32, 24))
+
+    };
+  }
+}
+
+// Test case 4: Should error without derived relationship
+class Unrelated {
+>Unrelated : Symbol(Unrelated, Decl(protectedAccessViaExplicitThisParameter.ts, 36, 1))
+
+  testUnrelated() {
+>testUnrelated : Symbol(Unrelated.testUnrelated, Decl(protectedAccessViaExplicitThisParameter.ts, 39, 17))
+
+    const fn = function(this: Unrelated) {
+>fn : Symbol(fn, Decl(protectedAccessViaExplicitThisParameter.ts, 41, 9))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 41, 24))
+>Unrelated : Symbol(Unrelated, Decl(protectedAccessViaExplicitThisParameter.ts, 36, 1))
+
+      Base.prototype.baseMethod.call(this); // Error: Unrelated not related to Base
+>Base.prototype.baseMethod.call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>Base.prototype.baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>Base.prototype : Symbol(Base.prototype)
+>Base : Symbol(Base, Decl(protectedAccessViaExplicitThisParameter.ts, 0, 0))
+>prototype : Symbol(Base.prototype)
+>baseMethod : Symbol(Base.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 3, 12))
+>call : Symbol(CallableFunction.call, Decl(lib.es5.d.ts, --, --))
+>this : Symbol(this, Decl(protectedAccessViaExplicitThisParameter.ts, 41, 24))
+
+    };
+  }
+}
+
+// Test case 5: Should still error for external access
+const instance = new Derived();
+>instance : Symbol(instance, Decl(protectedAccessViaExplicitThisParameter.ts, 48, 5))
+>Derived : Symbol(Derived, Decl(protectedAccessViaExplicitThisParameter.ts, 7, 1))
+
+instance.baseMethod(); // Error: external access to protected member
+>instance.baseMethod : Symbol(Derived.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 9, 28))
+>instance : Symbol(instance, Decl(protectedAccessViaExplicitThisParameter.ts, 48, 5))
+>baseMethod : Symbol(Derived.baseMethod, Decl(protectedAccessViaExplicitThisParameter.ts, 9, 28))
+