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

package/dist/analyzer/analyzerFileInfo.js

@@ -22,7 +22,7 @@ function isAnnotationEvaluationPostponed(fileInfo) {
     // It was tentatively approved for 3.12, but they decided to defer until the next
     // release to reduce the risk.
     // https://discuss.python.org/t/pep-649-deferred-evaluation-of-annotations-tentatively-accepted/21331
-    if (fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_13) {
+    if (fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_13)) {
         return true;
     }
     return false;

package/dist/analyzer/analyzerFileInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAAwD;AAuDxD,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,IAAI,6BAAa,CAAC,KAAK,EAAE;QACpE,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}
+{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAA4D;AAuD5D,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,CAAC,kBAAkB,CAAC,iCAAiB,CAAC,EAAE;QACnF,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}

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

@@ -355,7 +355,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.functionAnnotationComment) {
             this.walk(node.functionAnnotationComment);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
-                this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_5) {
+                this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_5)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.functionAnnotationComment);
             }
         }
@@ -732,7 +732,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.typeAnnotationComment) {
             this._evaluator.getType(node.typeAnnotationComment);
             if (this._fileInfo.diagnosticRuleSet.reportTypeCommentUsage !== 'none' &&
-                this._fileInfo.executionEnvironment.pythonVersion >= pythonVersion_1.PythonVersion.V3_6) {
+                this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_6)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage, localize_1.LocMessage.typeCommentDeprecated(), node.typeAnnotationComment);
             }
         }
@@ -853,7 +853,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // associated with f-strings that we need to validate. Determine whether
         // we're within an f-string (or multiple f-strings if nesting is used).
         const fStringContainers = [];
-        if (this._fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_12) {
+        if (this._fileInfo.executionEnvironment.pythonVersion.isLessThan(pythonVersion_1.pythonVersion3_12)) {
             let curNode = node;
             while (curNode) {
                 if (curNode.nodeType === 27 /* ParseNodeType.FormatString */) {
@@ -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.
@@ -3019,17 +3010,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (deprecatedForm) {
                 if (((0, types_1.isInstantiableClass)(type) && type.details.fullName === deprecatedForm.fullName) ||
                     ((_b = type.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) === deprecatedForm.fullName) {
-                    if (this._fileInfo.executionEnvironment.pythonVersion >= deprecatedForm.version) {
+                    if (this._fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(deprecatedForm.version)) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
                             if (this._fileInfo.diagnosticRuleSet.reportDeprecated === 'none') {
                                 this._evaluator.addDeprecated(localize_1.LocMessage.deprecatedType().format({
-                                    version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
+                                    version: deprecatedForm.version.toString(),
                                     replacement: deprecatedForm.replacementText,
                                 }), node);
                             }
                             else {
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportDeprecated, localize_1.LocMessage.deprecatedType().format({
-                                    version: (0, pythonVersion_1.versionToString)(deprecatedForm.version),
+                                    version: deprecatedForm.version.toString(),
                                     replacement: deprecatedForm.replacementText,
                                 }), node);
                             }
@@ -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,