@zzzen/pyright-internal 1.2.0-dev.20240623 → 1.2.0-dev.20240707

package/dist/analyzer/checker.js

@@ -575,7 +575,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 else {
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, new typeVarContext_1.TypeVarContext(), 
+                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
+                    /* destTypeVarContext */ undefined, 
                     /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
@@ -2084,82 +2085,91 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     _reportInvalidOverload(name, symbol) {
         const typedDecls = symbol.getTypedDeclarations();
-        if (typedDecls.length >= 1) {
-            const primaryDecl = typedDecls[0];
-            if (primaryDecl.type === 5 /* DeclarationType.Function */) {
-                const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-                const overloadedFunctions = (0, types_1.isOverloadedFunction)(type)
-                    ? types_1.OverloadedFunctionType.getOverloads(type)
-                    : (0, types_1.isFunction)(type) && types_1.FunctionType.isOverloaded(type)
-                        ? [type]
-                        : [];
-                if (overloadedFunctions.length === 1) {
-                    // There should never be a single overload.
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.name);
-                }
-                // If the file is not a stub and this is the first overload,
-                // verify that there is an implementation.
-                if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
-                    let implementationFunction;
-                    let exemptMissingImplementation = false;
-                    if ((0, types_1.isOverloadedFunction)(type)) {
-                        implementationFunction = types_1.OverloadedFunctionType.getImplementation(type);
-                        // If the implementation has no name, it was synthesized probably by a
-                        // decorator that used a callable with a ParamSpec that captured the
-                        // overloaded signature. We'll exempt it from this check.
-                        const overloads = types_1.OverloadedFunctionType.getOverloads(type);
-                        if (overloads.length > 0 && overloads[0].details.name === '') {
-                            exemptMissingImplementation = true;
-                        }
-                    }
-                    else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
-                        implementationFunction = type;
+        if (typedDecls.length === 0) {
+            return;
+        }
+        const primaryDecl = typedDecls[0];
+        if (primaryDecl.type !== 5 /* DeclarationType.Function */) {
+            return;
+        }
+        const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+        const overloadedFunctions = (0, types_1.isOverloadedFunction)(type)
+            ? types_1.OverloadedFunctionType.getOverloads(type)
+            : (0, types_1.isFunction)(type) && types_1.FunctionType.isOverloaded(type)
+                ? [type]
+                : [];
+        // If the implementation has no name, it was synthesized probably by a
+        // decorator that used a callable with a ParamSpec that captured the
+        // overloaded signature. We'll exempt it from this check.
+        if ((0, types_1.isOverloadedFunction)(type)) {
+            const overloads = types_1.OverloadedFunctionType.getOverloads(type);
+            if (overloads.length > 0 && overloads[0].details.name === '') {
+                return;
+            }
+        }
+        else if ((0, types_1.isFunction)(type)) {
+            if (type.details.name === '') {
+                return;
+            }
+        }
+        if (overloadedFunctions.length === 1) {
+            // There should never be a single overload.
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.name);
+        }
+        // If the file is not a stub and this is the first overload,
+        // verify that there is an implementation.
+        if (this._fileInfo.isStubFile || overloadedFunctions.length === 0) {
+            return;
+        }
+        let implementationFunction;
+        if ((0, types_1.isOverloadedFunction)(type)) {
+            implementationFunction = types_1.OverloadedFunctionType.getImplementation(type);
+        }
+        else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
+            implementationFunction = type;
+        }
+        if (!implementationFunction) {
+            const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
+            if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
+                const classType = this._evaluator.getTypeOfClass(containingClassNode);
+                if (classType) {
+                    if (types_1.ClassType.isProtocolClass(classType.classType)) {
+                        return;
                     }
-                    if (!implementationFunction) {
-                        const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
-                        if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
-                            const classType = this._evaluator.getTypeOfClass(containingClassNode);
-                            if (classType) {
-                                if (types_1.ClassType.isProtocolClass(classType.classType)) {
-                                    exemptMissingImplementation = true;
-                                }
-                                else if (types_1.ClassType.supportsAbstractMethods(classType.classType)) {
-                                    if ((0, types_1.isOverloadedFunction)(type) &&
-                                        types_1.OverloadedFunctionType.getOverloads(type).every((overload) => types_1.FunctionType.isAbstractMethod(overload))) {
-                                        exemptMissingImplementation = true;
-                                    }
-                                }
-                            }
-                        }
-                        // If this is a method within a protocol class, don't require that
-                        // there is an implementation.
-                        if (!exemptMissingImplementation) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
-                                name: primaryDecl.node.name.value,
-                            }), primaryDecl.node.name);
+                    if (types_1.ClassType.supportsAbstractMethods(classType.classType)) {
+                        if ((0, types_1.isOverloadedFunction)(type) &&
+                            types_1.OverloadedFunctionType.getOverloads(type).every((overload) => types_1.FunctionType.isAbstractMethod(overload))) {
+                            return;
                         }
                     }
-                    else if ((0, types_1.isOverloadedFunction)(type)) {
-                        // Verify that all overload signatures are assignable to implementation signature.
-                        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
-                            var _a, _b, _c, _d;
-                            const diag = new diagnostic_1.DiagnosticAddendum();
-                            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
-                                if (implementationFunction.details.declaration) {
-                                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
-                                        name,
-                                        index: index + 1,
-                                    }) + diag.getString(), implementationFunction.details.declaration.node.name);
-                                    if (diagnostic && overload.details.declaration) {
-                                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
-                                    }
-                                }
-                            }
-                        });
-                    }
                 }
             }
+            // If this is a method within a protocol class, don't require that
+            // there is an implementation.
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportNoOverloadImplementation, localize_1.LocMessage.overloadWithoutImplementation().format({
+                name: primaryDecl.node.name.value,
+            }), primaryDecl.node.name);
+            return;
+        }
+        if (!(0, types_1.isOverloadedFunction)(type)) {
+            return;
         }
+        // Verify that all overload signatures are assignable to implementation signature.
+        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
+            var _a, _b, _c, _d;
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
+                if (implementationFunction.details.declaration) {
+                    const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
+                        name,
+                        index: index + 1,
+                    }) + diag.getString(), implementationFunction.details.declaration.node.name);
+                    if (diagnostic && overload.details.declaration) {
+                        diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.details.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
+                    }
+                }
+            }
+        });
     }
     _reportMultipleFinalDeclarations(name, symbol, scopeType) {
         if (!this._evaluator.isFinalVariable(symbol)) {
@@ -2876,6 +2886,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.LocAddendum.genericClassNotAllowed());
                         isSupported = false;
                     }
+                    else if (types_1.ClassType.isIllegalIsinstanceClass(subtype)) {
+                        diag.addMessage(localize_1.LocAddendum.isinstanceClassNotSupported().format({ type: subtype.details.name }));
+                        isSupported = false;
+                    }
                     else if (types_1.ClassType.isProtocolClass(subtype) &&
                         !types_1.ClassType.isRuntimeCheckable(subtype) &&
                         !subtype.includeSubclasses) {