@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260816

package/dist/analyzer/checker.d.ts

@@ -132,6 +132,7 @@ export declare class Checker extends ParseTreeWalker {
     private _validateProtocolTypeParamVariance;
     private _validateSlotsClassVarConflict;
     private _validateConstructorConsistency;
+    private _validateDisjointBaseClass;
     private _validateMultipleInheritanceBaseClasses;
     private _validateMultipleInheritanceCompatibility;
     private _validateMultipleInheritanceOverride;

package/dist/analyzer/checker.js

@@ -192,6 +192,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateTypedDictOverrides(classTypeResult.classType);
             this._validateOverloadDecoratorConsistency(classTypeResult.classType);
+            this._validateDisjointBaseClass(classTypeResult.classType, node.d.name);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.d.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.d.name);
             this._validateConstructorConsistency(classTypeResult.classType, node.d.name);
@@ -3997,6 +3998,42 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    // Verifies that a class has a unique most-derived disjoint base.
+    _validateDisjointBaseClass(classType, errorNode) {
+        if (classType.shared.baseClasses.length < 2) {
+            return;
+        }
+        const candidates = [];
+        for (const baseClass of classType.shared.baseClasses) {
+            if (!(0, types_1.isInstantiableClass)(baseClass)) {
+                // An unknown base may introduce an unknown disjoint base, but it
+                // cannot make two already-incompatible known bases compatible,
+                // so keep collecting the known candidates.
+                continue;
+            }
+            const candidate = types_1.ClassType.getDisjointBase(baseClass);
+            if (!candidate) {
+                // The base class is invalid or its disjoint base is unknown; an
+                // unknown disjoint base cannot relate two otherwise-incompatible
+                // known candidates, so keep collecting the known candidates.
+                continue;
+            }
+            if (!candidates.some((existingCandidate) => types_1.ClassType.isSameGenericClass(existingCandidate, candidate))) {
+                candidates.push(candidate);
+            }
+        }
+        if (candidates.length > 1 && !types_1.ClassType.getMostDerivedDisjointBase(candidates)) {
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.disjointBaseIncompatible().format({
+                // `object` is a disjoint base but is compatible with every
+                // other disjoint base, so including it in the reported names
+                // would be misleading. Filter it out.
+                bases: candidates
+                    .filter((candidate) => !types_1.ClassType.isBuiltIn(candidate, 'object'))
+                    .map((candidate) => `"${candidate.shared.name}"`)
+                    .join(', '),
+            }), errorNode);
+        }
+    }
     // Verifies that classes that have more than one base class do not have
     // have conflicting type arguments.
     _validateMultipleInheritanceBaseClasses(classType, errorNode) {