Subsubclass can access protected constructor

src/compiler/checker.ts

@@ -13467,13 +13467,14 @@ namespace ts {
                 const containingClass = getContainingClass(node);
                 if (containingClass) {
                     const containingType = getTypeOfNode(containingClass);
-                    const baseTypes = getBaseTypes(<InterfaceType>containingType);
-                    if (baseTypes.length) {
+                    let baseTypes = getBaseTypes(containingType as InterfaceType);
+                    while (baseTypes.length) {
                         const baseType = baseTypes[0];
                         if (modifiers & ModifierFlags.Protected &&
                             baseType.symbol === declaration.parent.symbol) {
                             return true;
                         }
+                        baseTypes = getBaseTypes(baseType as InterfaceType);
                     }
                 }
                 if (modifiers & ModifierFlags.Private) {

tests/baselines/reference/subSubClassCanAccessProtectedConstructor.js

@@ -0,0 +1,51 @@
+//// [subSubClassCanAccessProtectedConstructor.ts]
+class Base {
+    protected constructor() { }
+    public instance1 = new Base(); // allowed
+}
+
+class Subclass extends Base {
+    public instance1_1 = new Base(); // allowed
+    public instance1_2 = new Subclass(); // allowed
+}
+
+class SubclassOfSubclass extends Subclass {
+    public instance2_1 = new Base(); // allowed
+    public instance2_2 = new Subclass(); // allowed
+    public instance2_3 = new SubclassOfSubclass(); // allowed
+}
+
+
+//// [subSubClassCanAccessProtectedConstructor.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var Base = (function () {
+    function Base() {
+        this.instance1 = new Base(); // allowed
+    }
+    return Base;
+}());
+var Subclass = (function (_super) {
+    __extends(Subclass, _super);
+    function Subclass() {
+        var _this = _super.apply(this, arguments) || this;
+        _this.instance1_1 = new Base(); // allowed
+        _this.instance1_2 = new Subclass(); // allowed
+        return _this;
+    }
+    return Subclass;
+}(Base));
+var SubclassOfSubclass = (function (_super) {
+    __extends(SubclassOfSubclass, _super);
+    function SubclassOfSubclass() {
+        var _this = _super.apply(this, arguments) || this;
+        _this.instance2_1 = new Base(); // allowed
+        _this.instance2_2 = new Subclass(); // allowed
+        _this.instance2_3 = new SubclassOfSubclass(); // allowed
+        return _this;
+    }
+    return SubclassOfSubclass;
+}(Subclass));

tests/baselines/reference/subSubClassCanAccessProtectedConstructor.symbols

@@ -0,0 +1,40 @@
+=== tests/cases/compiler/subSubClassCanAccessProtectedConstructor.ts ===
+class Base {
+>Base : Symbol(Base, Decl(subSubClassCanAccessProtectedConstructor.ts, 0, 0))
+
+    protected constructor() { }
+    public instance1 = new Base(); // allowed
+>instance1 : Symbol(Base.instance1, Decl(subSubClassCanAccessProtectedConstructor.ts, 1, 31))
+>Base : Symbol(Base, Decl(subSubClassCanAccessProtectedConstructor.ts, 0, 0))
+}
+
+class Subclass extends Base {
+>Subclass : Symbol(Subclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 3, 1))
+>Base : Symbol(Base, Decl(subSubClassCanAccessProtectedConstructor.ts, 0, 0))
+
+    public instance1_1 = new Base(); // allowed
+>instance1_1 : Symbol(Subclass.instance1_1, Decl(subSubClassCanAccessProtectedConstructor.ts, 5, 29))
+>Base : Symbol(Base, Decl(subSubClassCanAccessProtectedConstructor.ts, 0, 0))
+
+    public instance1_2 = new Subclass(); // allowed
+>instance1_2 : Symbol(Subclass.instance1_2, Decl(subSubClassCanAccessProtectedConstructor.ts, 6, 36))
+>Subclass : Symbol(Subclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 3, 1))
+}
+
+class SubclassOfSubclass extends Subclass {
+>SubclassOfSubclass : Symbol(SubclassOfSubclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 8, 1))
+>Subclass : Symbol(Subclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 3, 1))
+
+    public instance2_1 = new Base(); // allowed
+>instance2_1 : Symbol(SubclassOfSubclass.instance2_1, Decl(subSubClassCanAccessProtectedConstructor.ts, 10, 43))
+>Base : Symbol(Base, Decl(subSubClassCanAccessProtectedConstructor.ts, 0, 0))
+
+    public instance2_2 = new Subclass(); // allowed
+>instance2_2 : Symbol(SubclassOfSubclass.instance2_2, Decl(subSubClassCanAccessProtectedConstructor.ts, 11, 36))
+>Subclass : Symbol(Subclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 3, 1))
+
+    public instance2_3 = new SubclassOfSubclass(); // allowed
+>instance2_3 : Symbol(SubclassOfSubclass.instance2_3, Decl(subSubClassCanAccessProtectedConstructor.ts, 12, 40))
+>SubclassOfSubclass : Symbol(SubclassOfSubclass, Decl(subSubClassCanAccessProtectedConstructor.ts, 8, 1))
+}
+

tests/baselines/reference/subSubClassCanAccessProtectedConstructor.types

@@ -0,0 +1,46 @@
+=== tests/cases/compiler/subSubClassCanAccessProtectedConstructor.ts ===
+class Base {
+>Base : Base
+
+    protected constructor() { }
+    public instance1 = new Base(); // allowed
+>instance1 : Base
+>new Base() : Base
+>Base : typeof Base
+}
+
+class Subclass extends Base {
+>Subclass : Subclass
+>Base : Base
+
+    public instance1_1 = new Base(); // allowed
+>instance1_1 : Base
+>new Base() : Base
+>Base : typeof Base
+
+    public instance1_2 = new Subclass(); // allowed
+>instance1_2 : Subclass
+>new Subclass() : Subclass
+>Subclass : typeof Subclass
+}
+
+class SubclassOfSubclass extends Subclass {
+>SubclassOfSubclass : SubclassOfSubclass
+>Subclass : Subclass
+
+    public instance2_1 = new Base(); // allowed
+>instance2_1 : Base
+>new Base() : Base
+>Base : typeof Base
+
+    public instance2_2 = new Subclass(); // allowed
+>instance2_2 : Subclass
+>new Subclass() : Subclass
+>Subclass : typeof Subclass
+
+    public instance2_3 = new SubclassOfSubclass(); // allowed
+>instance2_3 : SubclassOfSubclass
+>new SubclassOfSubclass() : SubclassOfSubclass
+>SubclassOfSubclass : typeof SubclassOfSubclass
+}
+

tests/cases/compiler/subSubClassCanAccessProtectedConstructor.ts

@@ -0,0 +1,15 @@
+class Base {
+    protected constructor() { }
+    public instance1 = new Base(); // allowed
+}
+
+class Subclass extends Base {
+    public instance1_1 = new Base(); // allowed
+    public instance1_2 = new Subclass(); // allowed
+}
+
+class SubclassOfSubclass extends Subclass {
+    public instance2_1 = new Base(); // allowed
+    public instance2_2 = new Subclass(); // allowed
+    public instance2_3 = new SubclassOfSubclass(); // allowed
+}