Implemented a check for an attempt to invoke a static or class method…

… that is marked abstract. This addresses python/mypy#14939.
microsoft · May 13, 2023 · c51bb4b · c51bb4b
1 parent 773b619
commit c51bb4b
Show file tree

Hide file tree

Showing 5 changed files with 88 additions and 0 deletions.
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -7521,6 +7521,30 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                     addError(Localizer.Diagnostic.revealLocalsArgs(), node);
                 }
             } else {
+                // Check for an attempt to invoke an abstract static or class method.
+                if (
+                    isFunction(baseTypeResult.type) &&
+                    baseTypeResult.type.boundToType &&
+                    isInstantiableClass(baseTypeResult.type.boundToType) &&
+                    !baseTypeResult.type.boundToType.includeSubclasses
+                ) {
+                    if (FunctionType.isAbstractMethod(baseTypeResult.type)) {
+                        if (
+                            FunctionType.isStaticMethod(baseTypeResult.type) ||
+                            FunctionType.isClassMethod(baseTypeResult.type)
+                        ) {
+                            addDiagnostic(
+                                AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues,
+                                DiagnosticRule.reportGeneralTypeIssues,
+                                Localizer.Diagnostic.abstractMethodInvocation().format({
+                                    method: baseTypeResult.type.details.name,
+                                }),
+                                node.leftExpression
+                            );
+                        }
+                    }
+                }
+
                 const callResult = validateCallArguments(
                     node,
                     argList,

diff --git a/packages/pyright-internal/src/localization/localize.ts b/packages/pyright-internal/src/localization/localize.ts
@@ -167,6 +167,8 @@ export function loadStringsForLocale(locale: string, localeMap: Map<string, any>
 
 export namespace Localizer {
     export namespace Diagnostic {
+        export const abstractMethodInvocation = () =>
+            new ParameterizedString<{ method: string }>(getRawString('Diagnostic.abstractMethodInvocation'));
         export const annotatedParamCountMismatch = () =>
             new ParameterizedString<{ expected: number; received: number }>(
                 getRawString('Diagnostic.annotatedParamCountMismatch')

diff --git a/packages/pyright-internal/src/localization/package.nls.en-us.json b/packages/pyright-internal/src/localization/package.nls.en-us.json
@@ -1,5 +1,6 @@
 {
     "Diagnostic": {
+        "abstractMethodInvocation": "Method \"{method}\" cannot be called because it is abstract",
         "annotatedParamCountMismatch": "Parameter annotation count mismatch: expected {expected} but received {received}",
         "annotatedTypeArgMissing": "Expected one type argument and one or more annotations for \"Annotated\"",
         "annotationFormatString": "Type annotations cannot use format string literals (f-strings)",

diff --git a/packages/pyright-internal/src/tests/checker.test.ts b/packages/pyright-internal/src/tests/checker.test.ts
@@ -113,6 +113,12 @@ test('AbstractClass9', () => {
     TestUtils.validateResults(analysisResults, 0);
 });
 
+test('AbstractClass10', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['abstractClass10.py']);
+
+    TestUtils.validateResults(analysisResults, 6);
+});
+
 test('Constants1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['constants1.py']);
 

diff --git a/packages/pyright-internal/src/tests/samples/abstractClass10.py b/packages/pyright-internal/src/tests/samples/abstractClass10.py
@@ -0,0 +1,55 @@
+# This sample tests the detection of static or class method invocations
+# where the method is marked abstract.
+
+from abc import ABC, abstractmethod
+
+
+class A(ABC):
+    @staticmethod
+    @abstractmethod
+    def method1() -> None:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def method2(cls) -> None:
+        ...
+
+
+# This should generate an error.
+A.method1()
+
+# This should generate an error.
+A.method2()
+
+
+class B(A):
+    @staticmethod
+    def method1() -> None:
+        # This should generate an error.
+        return super().method1()
+
+    @classmethod
+    def method2(cls) -> None:
+        # This should generate an error.
+        return super().method2()
+
+
+B.method1()
+B.method2()
+
+
+def func1(a: type[A]):
+    a.method1()
+    a.method2()
+
+
+class C(A):
+    ...
+
+
+# This should generate an error.
+C.method1()
+
+# This should generate an error.
+C.method2()