fixup! flag abstract base classes with no abstract methods

Author: KotlinIsland

packages/pyright-internal/src/analyzer/typeEvaluator.ts

@@ -10796,8 +10796,9 @@ export function createTypeEvaluator(
                 isInstantiableClass(expandedCallType.shared.declaredMetaclass) &&
                 expandedCallType.shared.declaredMetaclass.shared.fullName === 'abc.ABCMeta';
 
+            // Handle abstract classes with abstract methods (reportAbstractUsage)
             if (
-                (abstractSymbols.length > 0 || derivesDirectlyFromABC || hasABCMetaMetaclass) &&
+                abstractSymbols.length > 0 &&
                 !expandedCallType.priv.includeSubclasses &&
                 !isTypeVar(unexpandedCallType)
             ) {
@@ -10833,6 +10834,20 @@ export function createTypeEvaluator(
                     errorNode
                 );
             }
+            // Handle abstract classes with no abstract methods (reportEmptyAbstractClass)
+            else if (
+                (derivesDirectlyFromABC || hasABCMetaMetaclass) &&
+                !expandedCallType.priv.includeSubclasses &&
+                !isTypeVar(unexpandedCallType)
+            ) {
+                addDiagnostic(
+                    DiagnosticRule.reportEmptyAbstractClass,
+                    LocMessage.instantiateAbstract().format({
+                        type: expandedCallType.shared.name,
+                    }),
+                    errorNode
+                );
+            }
         }
 
         if (ClassType.isProtocolClass(expandedCallType) && !expandedCallType.priv.includeSubclasses) {

packages/pyright-internal/src/common/configOptions.ts

@@ -189,6 +189,9 @@ export interface DiagnosticRuleSet {
     // Report use of abstract method or variable?
     reportAbstractUsage: DiagnosticLevel;
 
+    // Report instantiation of abstract class with no abstract methods?
+    reportEmptyAbstractClass: DiagnosticLevel;
+
     // Report argument type incompatibilities?
     reportArgumentType: DiagnosticLevel;
 
@@ -481,6 +484,7 @@ export function getDiagLevelDiagnosticRules() {
         DiagnosticRule.reportDuplicateImport,
         DiagnosticRule.reportWildcardImportFromLibrary,
         DiagnosticRule.reportAbstractUsage,
+        DiagnosticRule.reportEmptyAbstractClass,
         DiagnosticRule.reportArgumentType,
         DiagnosticRule.reportAssertTypeFailure,
         DiagnosticRule.reportAssignmentType,
@@ -617,6 +621,7 @@ export function getOffDiagnosticRuleSet(): DiagnosticRuleSet {
         reportDuplicateImport: 'none',
         reportWildcardImportFromLibrary: 'none',
         reportAbstractUsage: 'none',
+        reportEmptyAbstractClass: 'none',
         reportArgumentType: 'none',
         reportAssertTypeFailure: 'none',
         reportAssignmentType: 'none',
@@ -737,6 +742,7 @@ export function getBasicDiagnosticRuleSet(): DiagnosticRuleSet {
         reportDuplicateImport: 'none',
         reportWildcardImportFromLibrary: 'warning',
         reportAbstractUsage: 'error',
+        reportEmptyAbstractClass: 'error',
         reportArgumentType: 'error',
         reportAssertTypeFailure: 'error',
         reportAssignmentType: 'error',
@@ -857,6 +863,7 @@ export function getStandardDiagnosticRuleSet(): DiagnosticRuleSet {
         reportDuplicateImport: 'none',
         reportWildcardImportFromLibrary: 'warning',
         reportAbstractUsage: 'error',
+        reportEmptyAbstractClass: 'error',
         reportArgumentType: 'error',
         reportAssertTypeFailure: 'error',
         reportAssignmentType: 'error',
@@ -976,6 +983,7 @@ export const getRecommendedDiagnosticRuleSet = (): DiagnosticRuleSet => ({
     reportDuplicateImport: 'warning',
     reportWildcardImportFromLibrary: 'warning',
     reportAbstractUsage: 'error',
+    reportEmptyAbstractClass: 'error',
     reportArgumentType: 'error',
     reportAssertTypeFailure: 'error',
     reportAssignmentType: 'error',
@@ -1092,6 +1100,7 @@ export const getAllDiagnosticRuleSet = (): DiagnosticRuleSet => ({
     reportDuplicateImport: 'error',
     reportWildcardImportFromLibrary: 'error',
     reportAbstractUsage: 'error',
+    reportEmptyAbstractClass: 'error',
     reportArgumentType: 'error',
     reportAssertTypeFailure: 'error',
     reportAssignmentType: 'error',
@@ -1209,6 +1218,7 @@ export function getStrictDiagnosticRuleSet(): DiagnosticRuleSet {
         reportDuplicateImport: 'error',
         reportWildcardImportFromLibrary: 'error',
         reportAbstractUsage: 'error',
+        reportEmptyAbstractClass: 'error',
         reportArgumentType: 'error',
         reportAssertTypeFailure: 'error',
         reportAssignmentType: 'error',

packages/pyright-internal/src/common/diagnosticRules.ts

@@ -38,6 +38,7 @@ export enum DiagnosticRule {
     reportDuplicateImport = 'reportDuplicateImport',
     reportWildcardImportFromLibrary = 'reportWildcardImportFromLibrary',
     reportAbstractUsage = 'reportAbstractUsage',
+    reportEmptyAbstractClass = 'reportEmptyAbstractClass',
     reportArgumentType = 'reportArgumentType',
     reportAssertTypeFailure = 'reportAssertTypeFailure',
     reportAssignmentType = 'reportAssignmentType',

packages/pyright-internal/src/tests/checker.test.ts

@@ -131,7 +131,16 @@ test('AbstractClass11', () => {
 test('AbstractClass12', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['abstractClass12.py']);
 
-    TestUtils.validateResultsButBased(analysisResults, {});
+    TestUtils.validateResultsButBased(analysisResults, {
+        // one error to validate code and message, the rest use `pyright: ignore`
+        errors: [
+            {
+                line: 14,
+                message: 'Cannot instantiate abstract class "AbstractFoo"',
+                code: DiagnosticRule.reportEmptyAbstractClass,
+            },
+        ],
+    });
 });
 
 test('Constants1', () => {

packages/pyright-internal/src/tests/samples/abstractClass12.py

@@ -12,7 +12,7 @@ class Foo(AbstractFoo):
 
 # this should generate an error because `AbstractFoo`
 # is an abstract class even though it has no abstract methods
-a = AbstractFoo()  # pyright: ignore[reportAbstractUsage]
+a = AbstractFoo()
 
 # this should not generate an error because Foo is concrete
 b = Foo()
@@ -58,7 +58,7 @@ def static_method():
 
 
 # This should generate an error even though all methods are concrete
-h = AbstractWithMethods()  # pyright: ignore[reportAbstractUsage]
+h = AbstractWithMethods()  # pyright: ignore[reportEmptyAbstractClass]
 
 
 class AbstractWithMetaclass(metaclass=ABCMeta):
@@ -69,7 +69,7 @@ class ConcreteWithMetaclass(AbstractWithMetaclass):
 
 
 # this should generate an error because AbstractWithMetaclass uses ABCMeta
-i = AbstractWithMetaclass()  # pyright: ignore[reportAbstractUsage]
+i = AbstractWithMetaclass()  # pyright: ignore[reportEmptyAbstractClass]
 
 # this should not generate an error
 j = ConcreteWithMetaclass()

packages/pyright-internal/src/tests/samples/async1.py

@@ -9,7 +9,7 @@ async def b():
         yield i
 
 
-cm = AsyncExitStack()
+cm = AsyncExitStack()  # pyright: ignore[reportEmptyAbstractClass]  # typeshed moment
 
 
 def func1():

packages/pyright-internal/src/tests/samples/property2.py

@@ -21,7 +21,7 @@ def y(self) -> float:
         raise NotImplementedError
 
 
-a = Foo()
+a = Foo()  # pyright: ignore[reportEmptyAbstractClass]
 requires_int(a.x)
 
 a.x = 3

packages/vscode-pyright/package.json

@@ -490,6 +490,23 @@
                                 false
                             ]
                         },
+                        "reportEmptyAbstractClass": {
+                            "type": [
+                                "string",
+                                "boolean"
+                            ],
+                            "description": "Diagnostics for an attempt to instantiate an abstract class that has no abstract members.",
+                            "default": "error",
+                            "enum": [
+                                "none",
+                                "hint",
+                                "information",
+                                "warning",
+                                "error",
+                                true,
+                                false
+                            ]
+                        },
                         "reportArgumentType": {
                             "type": [
                                 "string",

packages/vscode-pyright/schemas/pyrightconfig.schema.json

@@ -185,6 +185,11 @@
       "title": "Controls reporting of attempted instantiation of abstract class",
       "default": "error"
     },
+    "reportEmptyAbstractClass": {
+      "$ref": "#/definitions/diagnostic",
+      "title": "Controls reporting of attempted instantiation of empty abstract class",
+      "default": "error"
+    },
     "reportArgumentType": {
       "$ref": "#/definitions/diagnostic",
       "title": "Controls reporting of incompatible argument type",
@@ -744,6 +749,9 @@
     "reportAbstractUsage": {
       "$ref": "#/definitions/reportAbstractUsage"
     },
+    "reportEmptyAbstractClass": {
+      "$ref": "#/definitions/reportEmptyAbstractClass"
+    },
     "reportArgumentType": {
       "$ref": "#/definitions/reportArgumentType"
     },