Fix exhaustive match checking for final class objects

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

@@ -1334,6 +1334,29 @@ function narrowTypeBasedOnValuePattern(
                     (subjectSubtypeExpanded) => {
                         // If this is a negative test, see if it's an enum value.
                         if (!isPositiveTest) {
+                            if (
+                                isInstantiableClass(subjectSubtypeExpanded) &&
+                                isInstantiableClass(valueSubtypeExpanded) &&
+                                isSameWithoutLiteralValue(subjectSubtypeExpanded, valueSubtypeExpanded)
+                            ) {
+                                // A value pattern compares with ==, not identity. Ensure that the
+                                // class has standard equality semantics by checking if its metaclass
+                                // is the standard type (or ABCMeta) and hasn't been overridden with a
+                                // custom metaclass that might implement a custom __eq__.
+                                const metaclass = subjectSubtypeExpanded.shared.effectiveMetaclass;
+                                const isStandardEquality =
+                                    !metaclass ||
+                                    (isClass(metaclass) &&
+                                        ClassType.isBuiltIn(metaclass, ['type', 'ABCMeta', 'EnumMeta']));
+
+                                if (
+                                    isStandardEquality &&
+                                    (ClassType.isFinal(subjectSubtypeExpanded) ||
+                                        !subjectSubtypeExpanded.priv.includeSubclasses)
+                                ) {
+                                    return undefined;
+                                }
+                            }
                             if (
                                 isClassInstance(subjectSubtypeExpanded) &&
                                 isClassInstance(valueSubtypeExpanded) &&

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

@@ -0,0 +1,65 @@
+# pyright: reportMatchNotExhaustive=true
+
+from typing import final
+
+class Base:
+    pass
+
+@final
+class A1(Base):
+    pass
+
+@final
+class B1(Base):
+    pass
+
+class NS1:
+    A1 = A1
+    B1 = B1
+
+def exhaustive_final(inst: A1 | B1):
+    match type(inst):
+        case NS1.A1:
+            pass
+        case NS1.B1:
+            pass
+
+class A2(Base):
+    pass
+
+class B2(Base):
+    pass
+
+class NS2:
+    A2 = A2
+    B2 = B2
+
+def non_exhaustive_non_final(inst: A2 | B2):
+    match type(inst):
+        case NS2.A2:
+            pass
+        case NS2.B2:
+            pass
+
+class Meta(type):
+    def __eq__(self, other):
+        return False
+
+@final
+class C1(metaclass=Meta):
+    pass
+
+@final
+class D1(metaclass=Meta):
+    pass
+
+class NS3:
+    C1 = C1
+    D1 = D1
+
+def non_exhaustive_custom_meta(inst: C1 | D1):
+    match type(inst):
+        case NS3.C1:
+            pass
+        case NS3.D1:
+            pass

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

@@ -623,6 +623,14 @@ test('MatchMapping1', () => {
     TestUtils.validateResults(analysisResults, 2);
 });
 
+test('MatchClassFinal', () => {
+    const configOptions = new ConfigOptions(Uri.empty());
+
+    configOptions.defaultPythonVersion = pythonVersion3_12;
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['matchClassFinal.py'], configOptions);
+    TestUtils.validateResults(analysisResults, 2); // 1 error for non-final, 1 error for custom metaclass
+});
+
 test('MatchLiteral1', () => {
     const configOptions = new ConfigOptions(Uri.empty());