Add more check

microsoft · DanielRosenwasser · Mar 26, 2021 · Jul 15, 2020 · Jul 17, 2020 · Jul 17, 2020
commit 061cd27da6dadcaaed23ffaab38bae20a343808c
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -34375,7 +34375,9 @@ namespace ts {
                 }
             }
 
-            issueMemberWithOverride(node, type, typeWithThis);
+            if (compilerOptions.pedanticOverride) {
+                issueMemberWithOverride(node, type, typeWithThis);
+            }
 
             const implementedTypeNodes = getEffectiveImplementsTypeNodes(node);
             if (implementedTypeNodes) {
@@ -34411,32 +34413,31 @@ namespace ts {
             }
         }
 
-        function issueMemberWithOverride (node: ClassLikeDeclaration, type: InterfaceType, typeWithThis: Type) {
+        function issueMemberWithOverride(node: ClassLikeDeclaration, type: InterfaceType, typeWithThis: Type) {
             const baseTypeNode = getEffectiveBaseTypeNode(node);
+            const baseTypes = baseTypeNode && getBaseTypes(type);
+            const baseWithThis = baseTypes?.length ? getTypeWithThisArgument(first(baseTypes), type.thisType) : undefined;
+
             for (const member of node.members) {
                 const hasOverride = hasOverrideModifier(member);
-                if (hasOverride && !baseTypeNode) {
-                    error(member, Diagnostics._0_is_deprecated, 'has override but not extended')
-                }
-                else if (baseTypeNode) {
-                    const baseTypes = getBaseTypes(type);
-                    if (baseTypes.length) {
-                        const baseType = first(baseTypes);
-                        const baseWithThis = getTypeWithThisArgument(baseType, type.thisType);
-
-                        const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
-                        if (declaredProp) {
-                            const prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
-                            const baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
-                            if (prop && !baseProp && hasOverride) {
-                                error(member, Diagnostics._0_is_deprecated, 'not founded in base class')
-                            }
-                            else if (prop && baseProp && !hasOverride) {
-                                error(member, Diagnostics._0_is_deprecated, 'need override')
-                            }
+                if (baseWithThis) {
+                    const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
+                    if (declaredProp) {
+                        const baseClassName = typeToString(baseWithThis);
+                        const prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
+                        const baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
+                        if (prop && !baseProp && hasOverride) {
+                            error(member, Diagnostics.Method_cannot_have_override_modifier_because_it_s_not_existed_in_the_base_class_0, baseClassName);
+                        }
+                        else if (prop && baseProp && !hasOverride) {
+                            error(member, Diagnostics.Method_must_have_override_modifier_because_it_s_override_the_base_class_0, baseClassName);
                         }
                     }
                 }
+                else if (hasOverride) {
+                    const className = typeToString(type);
+                    error(member, Diagnostics.Method_cannot_have_override_modifier_because_class_0_does_not_extended_another_class, className);
+                }
             }
         }
 

diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -606,6 +606,14 @@ namespace ts {
             category: Diagnostics.Additional_Checks,
             description: Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
         },
+        {
+            name: "pedanticOverride",
+            type: "boolean",
+            affectsSemanticDiagnostics: true,
+            showInSimplifiedHelpView: false,
+            category: Diagnostics.Additional_Checks,
+            description: Diagnostics.Required_override_modifier_in_class_element
+        },
 
         // Module Resolution
         {

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -3361,6 +3361,18 @@
         "category": "Error",
         "code": 4110
     },
+    "Method cannot have override modifier because class '{0}' does not extended another class.": {
+        "category": "Error",
+        "code": 4111
+    },
+    "Method cannot have override modifier because it's not existed in the base class '{0}'.": {
+        "category": "Error",
+        "code": 4112
+    },
+    "Method must have override modifier because it's override the base class '{0}'.": {
+        "category": "Error",
+        "code": 4113
+    },
 
     "The current host does not support the '{0}' option.": {
         "category": "Error",
@@ -4653,6 +4665,10 @@
         "category": "Error",
         "code": 6504
     },
+    "Required override modifier in class element": {
+        "category": "Error",
+        "code": 6801
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -5719,6 +5719,7 @@ namespace ts {
         paths?: MapLike<string[]>;
         /*@internal*/ plugins?: PluginImport[];
         preserveConstEnums?: boolean;
+        pedanticOverride?: boolean;
         preserveSymlinks?: boolean;
         /* @internal */ preserveWatchOutput?: boolean;
         project?: string;

diff --git a/tests/baselines/reference/override1.errors.txt b/tests/baselines/reference/override1.errors.txt
@@ -1,40 +1,71 @@
-tests/cases/conformance/override/override1.ts(15,5): suggestion TS6385: 'need override' is deprecated
-tests/cases/conformance/override/override1.ts(19,14): suggestion TS6385: 'not founded in base class' is deprecated
-tests/cases/conformance/override/override1.ts(25,14): suggestion TS6385: 'has override but not extended' is deprecated
+tests/cases/conformance/override/override1.ts(9,5): error TS4113: Method must have override modifier because it's override the base class 'B'.
+tests/cases/conformance/override/override1.ts(11,14): error TS4112: Method cannot have override modifier because it's not existed in the base class 'B'.
+tests/cases/conformance/override/override1.ts(15,14): error TS4111: Method cannot have override modifier because class 'C' does not extended another class.
+tests/cases/conformance/override/override1.ts(22,9): error TS4113: Method must have override modifier because it's override the base class 'B'.
+tests/cases/conformance/override/override1.ts(24,18): error TS4112: Method cannot have override modifier because it's not existed in the base class 'B'.
+tests/cases/conformance/override/override1.ts(33,5): error TS4113: Method must have override modifier because it's override the base class '(Anonymous class)'.
+tests/cases/conformance/override/override1.ts(37,14): error TS4112: Method cannot have override modifier because it's not existed in the base class '(Anonymous class)'.
+tests/cases/conformance/override/override1.ts(42,18): error TS4111: Method cannot have override modifier because class '(Anonymous class)' does not extended another class.
 
 
-==== tests/cases/conformance/override/override1.ts (3 errors) ====
+==== tests/cases/conformance/override/override1.ts (8 errors) ====
     class B {
-        foo (v: string) {
-
-        }
-        fooo (v: string) {
-
-        }
+        foo (v: string) {}
+        fooo (v: string) {}
     }
 
     class D extends B {
-        override foo (v: string) {
+        override foo (v: string) {}
 
-        }
-
-        fooo (v: string) {
+        fooo (v: string) {}
         ~~~~
-!!! suggestion TS6385: 'need override' is deprecated
-
-        }
+!!! error TS4113: Method must have override modifier because it's override the base class 'B'.
 
-        override bar(v: string) {
+        override bar(v: string) {}
                  ~~~
-!!! suggestion TS6385: 'not founded in base class' is deprecated
-
-        }
+!!! error TS4112: Method cannot have override modifier because it's not existed in the base class 'B'.
     }
 
     class C {
-        override foo(v: string) {
+        override foo(v: string) {}
                  ~~~
-!!! suggestion TS6385: 'has override but not extended' is deprecated
+!!! error TS4111: Method cannot have override modifier because class 'C' does not extended another class.
+    }
+
+    function f () {
+        return class extends B {
+            override foo (v: string) {}
+
+            fooo (v: string) {}
+            ~~~~
+!!! err
10000
or TS4113: Method must have override modifier because it's override the base class 'B'.
+
+            override bar(v: string) {}
+                     ~~~
+!!! error TS4112: Method cannot have override modifier because it's not existed in the base class 'B'.
+        }
+    }
+
+    class E extends (class {
+        foo () { }
+        bar () { }
+    }) {
+        override foo () { }
+        bar () { }
+        ~~~
+!!! error TS4113: Method must have override modifier because it's override the base class '(Anonymous class)'.
+
+        baz() {}
+
+        override bazz () {}
+                 ~~~~
+!!! error TS4112: Method cannot have override modifier because it's not existed in the base class '(Anonymous class)'.
+    }
 
+    function ff () {
+        return class {
+            override foo () {}
+                     ~~~
+!!! error TS4111: Method cannot have override modifier because class '(Anonymous class)' does not extended another class.
         }
     }
diff --git a/tests/baselines/reference/override1.js b/tests/baselines/reference/override1.js
@@ -1,30 +1,46 @@
 //// [override1.ts]
 class B {
-    foo (v: string) {
-
-    }
-    fooo (v: string) {
-
-    }
+    foo (v: string) {}
+    fooo (v: string) {}
 }
 
 class D extends B {
-    override foo (v: string) {
+    override foo (v: string) {}
 
-    }
+    fooo (v: string) {}
 
-    fooo (v: string) {
-
-    }
+    override bar(v: string) {}
+}
 
-    override bar(v: string) {
-
+class C {
+    override foo(v: string) {}
+}
+
+function f () {
+    return class extends B {
+        override foo (v: string) {}
+
+        fooo (v: string) {}
+
+        override bar(v: string) {}
     }
 }
 
-class C {
-    override foo(v: string) {
+class E extends (class {
+    foo () { }
+    bar () { }
+}) {
+    override foo () { }
+    bar () { }
+
+    baz() {}
 
+    override bazz () {}
+}
+
+function ff () {
+    return class {
+        override foo () {}
     }
 }
 
@@ -45,29 +61,60 @@ var __extends = (this && this.__extends) || (function () {
 var B = /** @class */ (function () {
     function B() {
     }
-    B.prototype.foo = function (v) {
-    };
-    B.prototype.fooo = function (v) {
-    };
+    B.prototype.foo = function (v) { };
+    B.prototype.fooo = function (v) { };
     return B;
 }());
 var D = /** @class */ (function (_super) {
     __extends(D, _super);
     function D() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    D.prototype.foo = function (v) {
-    };
-    D.prototype.fooo = function (v) {
-    };
-    D.prototype.bar = function (v) {
-    };
+    D.prototype.foo = function (v) { };
+    D.prototype.fooo = function (v) { };
+    D.prototype.bar = function (v) { };
     return D;
 }(B));
 var C = /** @class */ (function () {
     function C() {
     }
-    C.prototype.foo = function (v) {
-    };
+    C.prototype.foo = function (v) { };
     return C;
 }());
+function f() {
+    return /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.foo = function (v) { };
+        class_1.prototype.fooo = function (v) { };
+        class_1.prototype.bar = function (v) { };
+        return class_1;
+    }(B));
+}
+var E = /** @class */ (function (_super) {
+    __extends(E, _super);
+    function E() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    E.prototype.foo = function () { };
+    E.prototype.bar = function () { };
+    E.prototype.baz = function () { };
+    E.prototype.bazz = function () { };
+    return E;
+}((/** @class */ (function () {
+    function class_2() {
+    }
+    class_2.prototype.foo = function () { };
+    class_2.prototype.bar = function () { };
+    return class_2;
+}()))));
+function ff() {
+    return /** @class */ (function () {
+        function class_3() {
+        }
+        class_3.prototype.foo = function () { };
+        return class_3;
+    }());
+}