@zzzen/pyright-internal 1.2.0-dev.20240901 → 1.2.0-dev.20240915

package/dist/analyzer/checker.js

@@ -412,7 +412,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         this._scopedNodes.push(node);
-        if (functionTypeResult && (0, types_1.isOverloaded)(functionTypeResult.decoratedType)) {
+        if (functionTypeResult &&
+            (0, types_1.isOverloaded)(functionTypeResult.decoratedType) &&
+            functionTypeResult.functionType.priv.overloaded) {
             // If this is the implementation for the overloaded function, skip
             // overload consistency checks.
             if (types_1.OverloadedType.getImplementation(functionTypeResult.decoratedType) !== functionTypeResult.functionType) {
@@ -672,34 +674,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitRaise(node) {
-        this._evaluator.verifyRaiseExceptionType(node);
-        if (node.d.valueExpression) {
-            const baseExceptionType = this._evaluator.getBuiltInType(node, 'BaseException');
-            const exceptionType = this._evaluator.getType(node.d.valueExpression);
-            // Validate that the argument of "raise" is an exception object or None.
-            if (exceptionType && baseExceptionType && (0, types_1.isInstantiableClass)(baseExceptionType)) {
-                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
-                    subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
-                        if ((0, types_1.isClass)(subtype)) {
-                            if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
-                                diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                                    type: this._evaluator.printType(subtype),
-                                }));
-                            }
-                        }
-                        else {
-                            diagAddendum.addMessage(localize_1.LocMessage.exceptionTypeIncorrect().format({
-                                type: this._evaluator.printType(subtype),
-                            }));
-                        }
-                    }
-                });
-                if (!diagAddendum.isEmpty()) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.expectedExceptionObj() + diagAddendum.getString(), node.d.valueExpression);
-                }
-            }
+        if (node.d.expr) {
+            this._evaluator.verifyRaiseExceptionType(node.d.expr);
+        }
+        if (node.d.fromExpr) {
+            this._evaluator.verifyRaiseExceptionType(node.d.fromExpr);
         }
         return true;
     }
@@ -1009,11 +988,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitImportFromAs(node) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this._fileInfo.isStubFile) {
             return false;
         }
-        const decls = this._evaluator.getDeclarationsForNameNode(node.d.name);
+        const decls = (_a = this._evaluator.getDeclInfoForNameNode(node.d.name)) === null || _a === void 0 ? void 0 : _a.decls;
         if (!decls) {
             return false;
         }
@@ -1035,14 +1014,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             break;
         }
         let isImportFromTyping = false;
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
+        if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 25 /* ParseNodeType.ImportFrom */) {
             if (node.parent.d.module.d.leadingDots === 0 && node.parent.d.module.d.nameParts.length === 1) {
                 if (node.parent.d.module.d.nameParts[0].d.value === 'typing') {
                     isImportFromTyping = true;
                 }
             }
         }
-        const type = this._evaluator.getType((_b = node.d.alias) !== null && _b !== void 0 ? _b : node.d.name);
+        const type = this._evaluator.getType((_c = node.d.alias) !== null && _c !== void 0 ? _c : node.d.name);
         this._reportDeprecatedUseForType(node.d.name, type, isImportFromTyping);
         return false;
     }
@@ -1851,7 +1830,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // earlier overload. Typeshed stubs contain type: ignore comments on these
     // lines, so it is important for us to report them in the same manner.
     _findNodeForOverload(functionNode, overloadType) {
-        const decls = this._evaluator.getDeclarationsForNameNode(functionNode.d.name);
+        var _a;
+        const decls = (_a = this._evaluator.getDeclInfoForNameNode(functionNode.d.name)) === null || _a === void 0 ? void 0 : _a.decls;
         if (!decls) {
             return undefined;
         }
@@ -2739,161 +2719,40 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             curNode = curNode.parent;
         }
-        // Several built-in classes don't follow the normal class hierarchy
-        // rules, so we'll avoid emitting false-positive diagnostics if these
-        // are used.
-        const nonstandardClassTypes = [
-            'FunctionType',
-            'LambdaType',
-            'BuiltinFunctionType',
-            'BuiltinMethodType',
-            'type',
-            'Type',
-        ];
-        const classTypeList = [];
-        let arg1IncludesSubclasses = false;
-        (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
-            if ((0, types_1.isClass)(arg1Subtype)) {
-                if (types_1.TypeBase.isInstantiable(arg1Subtype)) {
-                    if (arg1Subtype.priv.literalValue === undefined) {
-                        classTypeList.push(arg1Subtype);
-                        if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
-                            nonstandardClassTypes.some((name) => name === arg1Subtype.shared.name)) {
-                            isValidType = false;
-                        }
-                        if (arg1Subtype.priv.includeSubclasses) {
-                            arg1IncludesSubclasses = true;
-                        }
-                    }
-                    if (arg0Type) {
-                        this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, (0, typeUtils_1.convertToInstance)(arg1Subtype), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
-                    }
-                }
-                else {
-                    // The isinstance and issubclass call supports a variation where the second
-                    // parameter is a tuple of classes.
-                    if ((0, typeUtils_1.isTupleClass)(arg1Subtype)) {
-                        if (arg1Subtype.priv.tupleTypeArgs) {
-                            arg1Subtype.priv.tupleTypeArgs.forEach((typeArg) => {
-                                if ((0, types_1.isInstantiableClass)(typeArg.type)) {
-                                    classTypeList.push(typeArg.type);
-                                    if (typeArg.type.priv.includeSubclasses) {
-                                        arg1IncludesSubclasses = true;
-                                    }
-                                    if (arg0Type) {
-                                        this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, (0, typeUtils_1.convertToInstance)(typeArg.type), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
-                                    }
-                                }
-                                else {
-                                    isValidType = false;
-                                }
-                            });
-                        }
-                    }
-                    else {
-                        if (arg1Subtype.priv.includeSubclasses) {
-                            arg1IncludesSubclasses = true;
-                        }
-                    }
-                    if (types_1.ClassType.isBuiltIn(arg1Subtype) &&
-                        nonstandardClassTypes.some((name) => name === arg1Subtype.shared.name)) {
-                        isValidType = false;
-                    }
-                }
-            }
-            else {
-                isValidType = false;
-            }
-        });
-        if (!isValidType) {
-            return;
-        }
-        if ((0, typeUtils_1.derivesFromAnyOrUnknown)(arg0Type)) {
+        const classTypeList = (0, typeGuards_1.getIsInstanceClassTypes)(this._evaluator, arg1Type);
+        if (!classTypeList) {
             return;
         }
-        const finalizeFilteredTypeList = (types) => {
-            return (0, types_1.combineTypes)(types);
-        };
-        const filterType = (varType) => {
-            const filteredTypes = [];
-            for (const filterType of classTypeList) {
-                const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, varType, filterType, filterType, isInstanceCheck);
-                const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, isInstanceCheck);
-                // Normally, a class should never be both a subclass and a
-                // superclass. However, this can happen if one of the classes
-                // derives from an unknown type. In this case, we'll add an
-                // unknown type into the filtered type list to avoid any
-                // false positives.
-                const isClassRelationshipIndeterminate = filterIsSuperclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
-                if (isClassRelationshipIndeterminate) {
-                    filteredTypes.push(types_1.UnknownType.create());
-                }
-                else if (filterIsSuperclass) {
-                    // If the variable type is a subclass of the isinstance
-                    // filter, we haven't learned anything new about the
-                    // variable type.
-                    filteredTypes.push(varType);
-                }
-                else if (filterIsSubclass) {
-                    // If the variable type is a superclass of the isinstance
-                    // filter, we can narrow the type to the subclass.
-                    filteredTypes.push(filterType);
-                }
-            }
-            if (!isInstanceCheck) {
-                return filteredTypes;
-            }
-            // Make all instantiable classes into instances before returning them.
-            return filteredTypes.map((t) => ((0, types_1.isInstantiableClass)(t) ? types_1.ClassType.cloneAsInstance(t) : t));
-        };
-        let filteredType;
-        if (isInstanceCheck && (0, types_1.isClassInstance)(arg0Type)) {
-            const remainingTypes = filterType(types_1.ClassType.cloneAsInstantiable(arg0Type));
-            filteredType = finalizeFilteredTypeList(remainingTypes);
-        }
-        else if (!isInstanceCheck && (0, types_1.isInstantiableClass)(arg0Type)) {
-            const remainingTypes = filterType(arg0Type);
-            filteredType = finalizeFilteredTypeList(remainingTypes);
-        }
-        else if ((0, types_1.isUnion)(arg0Type)) {
-            let remainingTypes = [];
-            let foundAnyType = false;
-            (0, typeUtils_1.doForEachSubtype)(arg0Type, (subtype) => {
-                if ((0, types_1.isAnyOrUnknown)(subtype)) {
-                    foundAnyType = true;
-                }
-                if (isInstanceCheck && (0, types_1.isClassInstance)(subtype)) {
-                    remainingTypes = remainingTypes.concat(filterType(types_1.ClassType.cloneAsInstantiable(subtype)));
-                }
-                else if (!isInstanceCheck && (0, types_1.isInstantiableClass)(subtype)) {
-                    remainingTypes = remainingTypes.concat(filterType(subtype));
-                }
-            });
-            filteredType = finalizeFilteredTypeList(remainingTypes);
-            // If we found an any or unknown type, all bets are off.
-            if (foundAnyType) {
-                return;
+        // Check for unsafe protocol overlaps.
+        classTypeList.forEach((filterType) => {
+            if ((0, types_1.isInstantiableClass)(filterType)) {
+                this._validateUnsafeProtocolOverlap(node.d.args[0].d.valueExpr, (0, typeUtils_1.convertToInstance)(filterType), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
             }
-        }
-        else {
-            return;
-        }
-        const getTestType = () => {
-            const objTypeList = classTypeList.map((t) => types_1.ClassType.cloneAsInstance(t));
-            return (0, types_1.combineTypes)(objTypeList);
-        };
-        // If arg1IncludesSubclasses is true, it contains a Type[X] class rather than X. A Type[X]
-        // could be a subclass of X, so the "unnecessary isinstance check" may be legit.
-        if (!arg1IncludesSubclasses && (0, types_1.isTypeSame)(filteredType, arg0Type, { ignorePseudoGeneric: true })) {
-            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, isInstanceCheck
-                ? localize_1.LocMessage.unnecessaryIsInstanceAlways().format({
-                    testType: this._evaluator.printType(arg0Type),
-                    classType: this._evaluator.printType(getTestType()),
-                })
-                : localize_1.LocMessage.unnecessaryIsSubclassAlways().format({
+        });
+        // Check for unnecessary isinstance or issubclass calls.
+        if (this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance !== 'none') {
+            const narrowedTypeNegative = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
+            /* isTypeIsCheck */ false, 
+            /* isPositiveTest */ false, node);
+            const narrowedTypePositive = (0, typeGuards_1.narrowTypeForInstanceOrSubclass)(this._evaluator, arg0Type, classTypeList, isInstanceCheck, 
+            /* isTypeIsCheck */ false, 
+            /* isPositiveTest */ true, node);
+            const isAlwaysTrue = (0, types_1.isNever)(narrowedTypeNegative);
+            const isNeverTrue = (0, types_1.isNever)(narrowedTypePositive);
+            if (isAlwaysTrue || isNeverTrue) {
+                const classType = (0, types_1.combineTypes)(classTypeList.map((t) => (0, typeUtils_1.convertToInstance)(t)));
+                const messageTemplate = isAlwaysTrue
+                    ? isInstanceCheck
+                        ? localize_1.LocMessage.unnecessaryIsInstanceAlways()
+                        : localize_1.LocMessage.unnecessaryIsSubclassAlways()
+                    : isInstanceCheck
+                        ? localize_1.LocMessage.unnecessaryIsInstanceNever()
+                        : localize_1.LocMessage.unnecessaryIsSubclassNever();
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance, messageTemplate.format({
                     testType: this._evaluator.printType(arg0Type),
-                    classType: this._evaluator.printType(getTestType()),
+                    classType: this._evaluator.printType(classType),
                 }), node);
+            }
         }
     }
     _validateUnsafeProtocolOverlap(errorNode, protocol, testType) {
@@ -3182,7 +3041,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (pythonVersion_1.PythonVersion.isGreaterOrEqualTo(this._fileInfo.executionEnvironment.pythonVersion, deprecatedForm.version)) {
                         if (!deprecatedForm.typingImportOnly || isImportFromTyping) {
                             this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedType().format({
-                                version: deprecatedForm.version.toString(),
+                                version: pythonVersion_1.PythonVersion.toString(deprecatedForm.version),
                                 replacement: deprecatedForm.replacementText,
                             }));
                         }
@@ -3306,7 +3165,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _conditionallyReportPrivateUsage(node) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this._fileInfo.diagnosticRuleSet.reportPrivateUsage === 'none') {
             return;
         }
@@ -3329,8 +3188,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Get the declarations for this name node, but filter out
         // any variable declarations that are bound using nonlocal
         // or global explicit bindings.
-        const declarations = (_b = this._evaluator
-            .getDeclarationsForNameNode(node)) === null || _b === void 0 ? void 0 : _b.filter((decl) => decl.type !== 1 /* DeclarationType.Variable */ || !decl.isExplicitBinding);
+        const declarations = (_c = (_b = this._evaluator
+            .getDeclInfoForNameNode(node)) === null || _b === void 0 ? void 0 : _b.decls) === null || _c === void 0 ? void 0 : _c.filter((decl) => decl.type !== 1 /* DeclarationType.Variable */ || !decl.isExplicitBinding);
         let primaryDeclaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : undefined;
         if (!primaryDeclaration || primaryDeclaration.node === node) {
             return;
@@ -3465,7 +3324,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (isTypeIs) {
             const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
-            const typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(returnType.priv.typeArgs[0], scopeIds);
+            const narrowedType = returnType.priv.typeArgs[0];
+            let typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(narrowedType, scopeIds);
+            typeGuardType = types_1.TypeBase.cloneWithTypeForm(typeGuardType, typeGuardType);
             // Determine the type of the first parameter.
             const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
             if (paramIndex >= functionType.shared.parameters.length) {
@@ -3478,7 +3339,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (returnAnnotation) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeIsReturnType().format({
                         type: this._evaluator.printType(paramType),
-                        returnType: this._evaluator.printType(typeGuardType),
+                        returnType: this._evaluator.printType(narrowedType),
                     }), returnAnnotation);
                 }
             }
@@ -3604,7 +3465,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         className: parentSymbol.classType.shared.name,
                     }), decl.node);
                 }
-                else if (types_1.ClassType.isReadOnlyInstanceVariables(parentSymbol.classType) &&
+                else if (types_1.ClassType.hasNamedTupleEntry(parentSymbol.classType, name) &&
                     !SymbolNameUtils.isDunderName(name)) {
                     // If the parent class is a named tuple, all instance variables
                     // (other than dundered ones) are implicitly final.
@@ -3893,7 +3754,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // If this is part of a dataclass, a class handled by a dataclass_transform,
                     // or a NamedTuple, exempt it because the class variable will be transformed
                     // into an instance variable in this case.
-                    if (types_1.ClassType.isDataClass(classType) || types_1.ClassType.isReadOnlyInstanceVariables(classType)) {
+                    if (types_1.ClassType.isDataClass(classType) || types_1.ClassType.hasNamedTupleEntry(classType, name)) {
                         return true;
                     }
                     // If this is part of a TypedDict, exempt it because the class variables