flag abstract base classes with no abstract methods

Author: KotlinIsland

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

@@ -10786,9 +10786,18 @@ export function createTypeEvaluator(
 
         if (ClassType.supportsAbstractMethods(expandedCallType)) {
             const abstractSymbols = getAbstractSymbols(expandedCallType);
+            // Check if ABC is in the direct base classes (not just anywhere in MRO)
+            const derivesDirectlyFromABC = expandedCallType.shared.baseClasses.some(
+                (baseClass) => isInstantiableClass(baseClass) && baseClass.shared.fullName == 'abc.ABC'
+            );
+            // Check if the class uses ABCMeta as its metaclass
+            const hasABCMetaMetaclass =
+                expandedCallType.shared.declaredMetaclass &&
+                isInstantiableClass(expandedCallType.shared.declaredMetaclass) &&
+                expandedCallType.shared.declaredMetaclass.shared.fullName == 'abc.ABCMeta';
 
             if (
-                abstractSymbols.length > 0 &&
+                (abstractSymbols.length > 0 || derivesDirectlyFromABC || hasABCMetaMetaclass) &&
                 !expandedCallType.priv.includeSubclasses &&
                 !isTypeVar(unexpandedCallType)
             ) {

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

@@ -128,6 +128,12 @@ test('AbstractClass11', () => {
     TestUtils.validateResults(analysisResults, 2);
 });
 
+test('AbstractClass12', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['abstractClass12.py']);
+
+    TestUtils.validateResultsButBased(analysisResults, {});
+});
+
 test('Constants1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['constants1.py']);
 

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

@@ -0,0 +1,75 @@
+# this sample tests the type analyzer's ability to flag attempts
+# to instantiate abstract base classes that have no abstract methods
+
+from abc import ABC, ABCMeta
+
+
+class AbstractFoo(ABC):
+    """an abstract class with no abstract methods"""
+
+class Foo(AbstractFoo):
+    """a concrete subclass"""
+
+# this should generate an error because `AbstractFoo`
+# is an abstract class even though it has no abstract methods
+a = AbstractFoo()  # pyright: ignore[reportAbstractUsage]
+
+# this should not generate an error because Foo is concrete
+b = Foo()
+
+
+class NotAbstract:
+    """a regular class that doesn't derive from ABC"""
+
+# This should not generate an error because NotAbstract is not abstract
+e = NotAbstract()
+
+
+class IndirectlyAbstract(AbstractFoo):
+    """inherits from an abstract class but doesn't override anything"""
+
+
+# this should not generate an error because IndirectlyAbstract
+# doesn't directly inherit from ABC (only through AbstractFoo)
+f = IndirectlyAbstract()
+
+
+class ConcreteClass(AbstractFoo):
+    """a concrete class that properly inherits from AbstractFoo"""
+
+
+# This should not generate an error
+g = ConcreteClass()
+
+
+class AbstractWithMethods(ABC):
+    """abstract class with no abstract methods but regular methods"""
+
+    def regular_method(self):
+        return 1
+
+    @classmethod
+    def class_method(cls):
+        return 2
+
+    @staticmethod
+    def static_method():
+        return 3
+
+
+# This should generate an error even though all methods are concrete
+h = AbstractWithMethods()  # pyright: ignore[reportAbstractUsage]
+
+
+class AbstractWithMetaclass(metaclass=ABCMeta):
+    """abstract class using ABCMeta metaclass with no abstract methods"""
+
+class ConcreteWithMetaclass(AbstractWithMetaclass):
+    """concrete subclass of AbstractWithMetaclass"""
+
+
+# this should generate an error because AbstractWithMetaclass uses ABCMeta
+i = AbstractWithMetaclass()  # pyright: ignore[reportAbstractUsage]
+
+# this should not generate an error
+j = ConcreteWithMetaclass()