@zzzen/pyright-internal 1.2.0-dev.20260802 → 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);
@@ -3247,30 +3248,49 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    // Verifies the rules specified in PEP 589 about TypedDict classes.
-    // They cannot have statements other than type annotations, doc
-    // strings, and "pass" statements or ellipses.
+    // Verifies the rules specified for TypedDict class bodies.
+    // They cannot have statements other than type annotations, doc strings,
+    // "pass" statements, ellipses, and statically evaluable if statements.
     _validateTypedDictClassSuite(suiteNode) {
         const emitBadStatementError = (node) => {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBadVar(), node);
         };
-        suiteNode.d.statements.forEach((statement) => {
-            if (!AnalyzerNodeInfo.isCodeUnreachable(statement)) {
-                if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
-                    for (const substatement of statement.d.statements) {
-                        if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
-                            substatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
-                            substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
-                            substatement.nodeType !== 42 /* ParseNodeType.Pass */) {
-                            emitBadStatementError(substatement);
-                        }
+        function validateStatement(statement) {
+            if (AnalyzerNodeInfo.isCodeUnreachable(statement)) {
+                return;
+            }
+            if (statement.nodeType === 47 /* ParseNodeType.StatementList */) {
+                for (const substatement of statement.d.statements) {
+                    if (substatement.nodeType !== 54 /* ParseNodeType.TypeAnnotation */ &&
+                        substatement.nodeType !== 21 /* ParseNodeType.Ellipsis */ &&
+                        substatement.nodeType !== 48 /* ParseNodeType.StringList */ &&
+                        substatement.nodeType !== 42 /* ParseNodeType.Pass */) {
+                        emitBadStatementError(substatement);
                     }
                 }
-                else {
+                return;
+            }
+            if (statement.nodeType === 22 /* ParseNodeType.If */) {
+                const conditionValue = AnalyzerNodeInfo.getStaticConditionValue(statement);
+                if (conditionValue === undefined) {
                     emitBadStatementError(statement);
+                    return;
+                }
+                const reachableSuite = conditionValue ? statement.d.ifSuite : statement.d.elseSuite;
+                if (reachableSuite?.nodeType === 22 /* ParseNodeType.If */) {
+                    validateStatement(reachableSuite);
+                }
+                else if (reachableSuite) {
+                    validateSuite(reachableSuite);
                 }
+                return;
             }
-        });
+            emitBadStatementError(statement);
+        }
+        function validateSuite(suite) {
+            suite.d.statements.forEach((statement) => validateStatement(statement));
+        }
+        validateSuite(suiteNode);
     }
     _validateTypeGuardFunction(node, functionType, isMethod) {
         const returnType = functionType.shared.declaredReturnType;
@@ -3978,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) {