@zzzen/pyright-internal 1.2.0-dev.20240310 → 1.2.0-dev.20240317

package/dist/analyzer/checker.d.ts

@@ -93,6 +93,7 @@ export declare class Checker extends ParseTreeWalker {
     private _isLegalOverloadImplementation;
     private _walkStatementsAndReportUnreachable;
     private _validateStubStatement;
+    private _validateExceptionTypeRecursive;
     private _validateExceptionType;
     private _reportUnusedDunderAllSymbols;
     private _validateSymbolTables;

package/dist/analyzer/checker.js

@@ -1121,7 +1121,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         let isTypeBool = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
-        this._evaluator.mapSubtypesExpandTypeVars(operandType, /* conditionFilter */ undefined, (expandedSubtype) => {
+        this._evaluator.mapSubtypesExpandTypeVars(operandType, /* options */ undefined, (expandedSubtype) => {
             if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
                 return undefined;
             }
@@ -1556,7 +1556,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
                     let isExempt = nameType.details.constraints.length > 0 ||
-                        !!nameType.details.defaultType ||
+                        nameType.details.isDefaultExplicit ||
                         (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
                     if (!isExempt && baseExpression && subscriptIndex !== undefined) {
@@ -1604,7 +1604,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (constructorClass && nameType.scopeId === constructorClass.details.typeVarScopeId) {
                     const existingEntry = classTypeVarUsage.get(nameType.details.name);
                     const isParamTypeWithEllipsisUsage = ((_d = curParamNode === null || curParamNode === void 0 ? void 0 : curParamNode.defaultValue) === null || _d === void 0 ? void 0 : _d.nodeType) === 18 /* ParseNodeType.Ellipsis */;
-                    const isExempt = !!nameType.details.defaultType;
+                    const isExempt = !!nameType.details.isDefaultExplicit;
                     if (!existingEntry) {
                         classTypeVarUsage.set(nameType.details.name, {
                             typeVar: nameType,
@@ -1935,57 +1935,48 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _validateExceptionType(exceptionType, errorNode) {
-        var _a, _b;
-        const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
+    _validateExceptionTypeRecursive(exceptionType, diag, baseExceptionType, allowTuple) {
         const derivesFromBaseException = (classType) => {
             if (!baseExceptionType || !(0, types_1.isInstantiableClass)(baseExceptionType)) {
                 return true;
             }
             return (0, typeUtils_1.derivesFromClassRecursive)(classType, baseExceptionType, /* ignoreUnknown */ false);
         };
-        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-        let resultingExceptionType;
-        if ((0, types_1.isAnyOrUnknown)(exceptionType)) {
-            resultingExceptionType = exceptionType;
-        }
-        else {
-            if ((0, types_1.isInstantiableClass)(exceptionType)) {
-                if (!derivesFromBaseException(exceptionType)) {
-                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                        type: this._evaluator.printType(exceptionType),
-                    }));
-                }
-                resultingExceptionType = types_1.ClassType.cloneAsInstance(exceptionType);
+        (0, typeUtils_1.doForEachSubtype)(exceptionType, (exceptionSubtype) => {
+            if ((0, types_1.isAnyOrUnknown)(exceptionSubtype)) {
+                return;
             }
-            else if ((0, types_1.isClassInstance)(exceptionType)) {
-                const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
-                resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
-                    subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                    if ((0, types_1.isAnyOrUnknown)(subtype) || (0, types_1.isNever)(subtype)) {
-                        return subtype;
-                    }
-                    if ((0, types_1.isInstantiableClass)(subtype)) {
-                        if (!derivesFromBaseException(subtype)) {
-                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                                type: this._evaluator.printType(exceptionType),
-                            }));
-                        }
-                        return types_1.ClassType.cloneAsInstance(subtype);
+            if ((0, types_1.isClass)(exceptionSubtype)) {
+                if (types_1.TypeBase.isInstantiable(exceptionSubtype)) {
+                    if (!derivesFromBaseException(exceptionSubtype)) {
+                        diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                            type: this._evaluator.printType(exceptionSubtype),
+                        }));
                     }
-                    diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                        type: this._evaluator.printType(exceptionType),
-                    }));
-                    return types_1.UnknownType.create();
-                });
+                    return;
+                }
+                if (allowTuple && exceptionSubtype.tupleTypeArguments) {
+                    exceptionSubtype.tupleTypeArguments.forEach((typeArg) => {
+                        this._validateExceptionTypeRecursive(typeArg.type, diag, baseExceptionType, 
+                        /* allowTuple */ false);
+                    });
+                    return;
+                }
+                diag.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
+                    type: this._evaluator.printType(exceptionSubtype),
+                }));
             }
-        }
+        });
+    }
+    _validateExceptionType(exceptionType, errorNode) {
+        const baseExceptionType = this._evaluator.getBuiltInType(errorNode, 'BaseException');
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        this._validateExceptionTypeRecursive(exceptionType, diagAddendum, baseExceptionType, /* allowTuple */ true);
         if (!diagAddendum.isEmpty()) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.exceptionTypeNotClass().format({
                 type: this._evaluator.printType(exceptionType),
             }), errorNode);
         }
-        return resultingExceptionType || types_1.UnknownType.create();
     }
     _reportUnusedDunderAllSymbols(nodes) {
         // If this rule is disabled, don't bother doing the work.
@@ -4347,9 +4338,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             // If the symbol has no declaration, and the type is inferred,
-            // skip this check.
-            if (!symbol.hasTypedDeclarations() && !this._evaluator.isFinalVariable(symbol)) {
-                return;
+            // skip the type validation but still check for other issues like
+            // Final overrides and class/instance variable mismatches.
+            let validateType = true;
+            if (!symbol.hasTypedDeclarations()) {
+                validateType = false;
             }
             // Get the symbol type defined in this class.
             const typeOfSymbol = this._evaluator.getEffectiveTypeOfSymbol(symbol);
@@ -4374,7 +4367,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     continue;
                 }
                 firstOverride = firstOverride !== null && firstOverride !== void 0 ? firstOverride : baseClassAndSymbol;
-                this._validateBaseClassOverride(baseClassAndSymbol, symbol, typeOfSymbol, classType, name);
+                this._validateBaseClassOverride(baseClassAndSymbol, symbol, validateType ? typeOfSymbol : types_1.AnyType.create(), classType, name);
             }
             if (!firstOverride) {
                 // If this is a method decorated with @override, validate that there
@@ -4557,7 +4550,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Handle properties specially.
             if (!(0, typeUtils_1.isProperty)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
-                if (decls.length > 0) {
+                if (decls.length > 0 && overrideSymbol.isClassMember()) {
                     const lastDecl = decls[decls.length - 1];
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.propertyOverridden().format({
                         name: memberName,