Fix to issue 6154 - Overriding a method with a property in the derived class should not cause a compiler error

Author: elizabethdinella

src/compiler/checker.ts

@@ -24430,7 +24430,7 @@ namespace ts {
                             continue;
                         }
 
-                        if (isPrototypeProperty(base) && isPrototypeProperty(derived) || base.flags & SymbolFlags.PropertyOrAccessor && derived.flags & SymbolFlags.PropertyOrAccessor) {
+                        if (isPrototypeProperty(base) || base.flags & SymbolFlags.PropertyOrAccessor && derived.flags & SymbolFlags.PropertyOrAccessor) {
                             // method is overridden with method or property/accessor is overridden with property/accessor - correct case
                             continue;
                         }

tests/baselines/reference/propertyOverridingPrototype.js

@@ -0,0 +1,37 @@
+//// [propertyOverridingPrototype.ts]
+class Base {
+    foo() {
+    }
+}
+
+class Derived extends Base {
+    foo: () => { };
+}
+
+
+
+//// [propertyOverridingPrototype.js]
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var Base = /** @class */ (function () {
+    function Base() {
+    }
+    Base.prototype.foo = function () {
+    };
+    return Base;
+}());
+var Derived = /** @class */ (function (_super) {
+    __extends(Derived, _super);
+    function Derived() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Derived;
+}(Base));

tests/baselines/reference/propertyOverridingPrototype.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/propertyOverridingPrototype.ts ===
+class Base {
+>Base : Symbol(Base, Decl(propertyOverridingPrototype.ts, 0, 0))
+
+    foo() {
+>foo : Symbol(Base.foo, Decl(propertyOverridingPrototype.ts, 0, 12))
+    }
+}
+
+class Derived extends Base {
+>Derived : Symbol(Derived, Decl(propertyOverridingPrototype.ts, 3, 1))
+>Base : Symbol(Base, Decl(propertyOverridingPrototype.ts, 0, 0))
+
+    foo: () => { };
+>foo : Symbol(Derived.foo, Decl(propertyOverridingPrototype.ts, 5, 28))
+}
+
+

tests/baselines/reference/propertyOverridingPrototype.types

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/propertyOverridingPrototype.ts ===
+class Base {
+>Base : Base
+
+    foo() {
+>foo : () => void
+    }
+}
+
+class Derived extends Base {
+>Derived : Derived
+>Base : Base
+
+    foo: () => { };
+>foo : () => {}
+}
+
+

tests/cases/compiler/propertyOverridingPrototype.ts

@@ -0,0 +1,9 @@
+class Base {
+    foo() {
+    }
+}
+
+class Derived extends Base {
+    foo: () => { };
+}
+