@zzzen/pyright-internal 1.2.0-dev.20250330 → 1.2.0-dev.20250413

package/dist/analyzer/typeEvaluator.js

@@ -851,9 +851,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* useCoroutine */ false)
             : undefined;
         const exprTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        const awaitableResult = getTypeOfAwaitable(exprTypeResult, node.d.expr);
         const typeResult = {
-            type: getTypeOfAwaitable(exprTypeResult.type, node.d.expr),
-            isIncomplete: exprTypeResult.isIncomplete,
+            type: awaitableResult.type,
+            isIncomplete: exprTypeResult.isIncomplete || awaitableResult.isIncomplete,
             typeErrors: exprTypeResult.typeErrors,
         };
         if (exprTypeResult.isIncomplete) {
@@ -1576,7 +1577,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!boundMethodResult || boundMethodResult.typeErrors) {
             return undefined;
         }
-        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloaded)(boundMethodResult.type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(boundMethodResult.type)) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
@@ -1671,7 +1672,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const constructorType = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, subtype);
                         if (constructorType) {
                             (0, typeUtils_1.doForEachSubtype)(constructorType, (subtype) => {
-                                if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) {
+                                if ((0, types_1.isFunctionOrOverloaded)(subtype)) {
                                     addFunctionToSignature(subtype);
                                 }
                             });
@@ -1867,7 +1868,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
                         declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
                     }
-                    if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloaded)(declaredType)) {
+                    if ((0, types_1.isFunctionOrOverloaded)(declaredType)) {
                         if (bindFunction) {
                             declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType, 
                             /* memberClass */ undefined, 
@@ -1884,14 +1885,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // the result. According to PEP 492, await operates on an Awaitable
     // (object that provides an __await__ that returns a generator object).
     // If errorNode is undefined, no errors are reported.
-    function getTypeOfAwaitable(type, errorNode) {
+    function getTypeOfAwaitable(typeResult, errorNode) {
         if (!prefetched?.awaitableClass ||
             !(0, types_1.isInstantiableClass)(prefetched.awaitableClass) ||
             prefetched.awaitableClass.shared.typeParams.length !== 1) {
-            return types_1.UnknownType.create();
+            return { type: types_1.UnknownType.create(), isIncomplete: typeResult.isIncomplete };
         }
         const awaitableProtocolObj = types_1.ClassType.cloneAsInstance(prefetched.awaitableClass);
-        return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+        const isIncomplete = !!typeResult.isIncomplete;
+        const type = (0, typeUtils_1.mapSubtypes)(typeResult.type, (subtype) => {
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
@@ -1909,11 +1911,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return types_1.UnknownType.create();
                 }
             }
-            if (errorNode) {
+            if (errorNode && !typeResult.isIncomplete) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotAwaitable().format({ type: printType(subtype) }) + diag?.getString(), errorNode);
             }
             return types_1.UnknownType.create();
         });
+        return { type, isIncomplete };
     }
     // Validates that the type is an iterator and returns the iterated type
     // (i.e. the type returned from the '__next__' or '__anext__' method).
@@ -1921,6 +1924,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const iterMethodName = isAsync ? '__aiter__' : '__iter__';
         const nextMethodName = isAsync ? '__anext__' : '__next__';
         let isValidIterator = true;
+        let isIncomplete = typeResult.isIncomplete;
         let type = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(typeResult.type);
         type = makeTopLevelTypeVarsConcrete(type);
         type = (0, types_1.removeUnbound)(type);
@@ -1989,7 +1993,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                             // If it's an async iteration, there's an implicit
                             // 'await' operator applied.
-                            return getTypeOfAwaitable(nextReturnType, errorNode);
+                            const awaitableResult = getTypeOfAwaitable({ type: nextReturnType, isIncomplete: typeResult.isIncomplete }, errorNode);
+                            if (awaitableResult.isIncomplete) {
+                                isIncomplete = true;
+                            }
+                            return awaitableResult.type;
                         }
                         return undefined;
                     });
@@ -1999,13 +2007,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     diag.addAddendum(iterReturnTypeDiag);
                 }
             }
-            if (!typeResult.isIncomplete && emitNotIterableError) {
+            if (!isIncomplete && emitNotIterableError) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotIterable().format({ type: printType(subtype) }) + diag.getString(), errorNode);
             }
             isValidIterator = false;
             return undefined;
         });
-        return isValidIterator ? { type: iterableType, isIncomplete: typeResult.isIncomplete } : undefined;
+        return isValidIterator ? { type: iterableType, isIncomplete } : undefined;
     }
     // Validates that the type is an iterable and returns the iterable type argument.
     function getTypeOfIterable(typeResult, isAsync, errorNode, emitNotIterableError = true) {
@@ -2393,7 +2401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!typeResult.isIncomplete) {
-            reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
+            reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, typeResult.type, nameNode, ignoreEmptyContainers);
         }
         writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
@@ -2934,31 +2942,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                let annotationType = getTypeOfAnnotation(target.d.annotation, {
+                getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
-                if (annotationType) {
-                    const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
-                    annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
-                }
-                // Handle a bare "Final" or "ClassVar" in a special manner.
-                const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) &&
-                    (types_1.ClassType.isBuiltIn(annotationType, 'Final') || types_1.ClassType.isBuiltIn(annotationType, 'ClassVar'));
-                if (!isBareFinalOrClassVar) {
-                    const isTypeAliasAnnotation = (0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias');
-                    if (!isTypeAliasAnnotation) {
-                        if (assignType(annotationType, typeResult.type)) {
-                            // Don't attempt to narrow based on the annotated type if the type
-                            // is a enum because the annotated type in an enum doesn't reflect
-                            // the type of the symbol.
-                            if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                                typeResult = narrowTypeBasedOnAssignment(annotationType, typeResult);
-                            }
-                        }
-                    }
-                }
                 assignTypeToExpression(target.d.valueExpr, typeResult, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
@@ -4065,8 +4053,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If type is undefined, emit a general error message indicating that the
         // member could not be accessed.
         if (!type) {
-            const isFunctionRule = (0, types_1.isFunction)(baseType) ||
-                (0, types_1.isOverloaded)(baseType) ||
+            const isFunctionRule = (0, types_1.isFunctionOrOverloaded)(baseType) ||
                 ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'function'));
             if (!baseTypeResult.isIncomplete) {
                 let diagMessage = localize_1.LocMessage.memberAccess();
@@ -4260,7 +4247,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 resultType = descResult.type;
             }
-            else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloaded)(concreteSubtype)) {
+            else if ((0, types_1.isFunctionOrOverloaded)(concreteSubtype) && types_1.TypeBase.isInstance(concreteSubtype)) {
                 const typeResult = bindMethodForMemberAccess(subtype, concreteSubtype, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount);
                 resultType = typeResult.type;
                 if (typeResult.typeErrors) {
@@ -4389,7 +4376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { type: types_1.UnknownType.create(), typeErrors: true };
         }
-        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloaded)(methodType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(methodType)) {
             if ((0, types_1.isAnyOrUnknown)(methodType)) {
                 return { type: methodType };
             }
@@ -4433,7 +4420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* diag */ undefined, constraints);
                 accessMethodClass = solveAndApplyConstraints(accessMethodClass, constraints);
                 const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, getTypeClassType(), selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
-                if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloaded)(specializedType)) {
+                if ((0, types_1.isFunctionOrOverloaded)(specializedType)) {
                     methodType = specializedType;
                 }
             }
@@ -4693,7 +4680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 },
             });
         }
-        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloaded)(accessMemberType)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(accessMemberType)) {
             if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
                 return { type: accessMemberType };
             }
@@ -4796,16 +4783,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const variadicIndex = typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
         // Is there a *tuple[T, ...] somewhere in the type arguments that we can expand if needed?
         let srcUnboundedTupleType;
-        let srcUnboundedTupleIndex = typeArgs.findIndex((arg) => {
-            if ((0, types_1.isUnpackedClass)(arg.type) &&
-                arg.type.priv.tupleTypeArgs &&
-                arg.type.priv.tupleTypeArgs.length === 1 &&
-                arg.type.priv.tupleTypeArgs[0].isUnbounded) {
-                srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
-                return true;
+        const findUnboundedTupleIndex = (startArgIndex) => {
+            return typeArgs.findIndex((arg, index) => {
+                if (index < startArgIndex) {
+                    return false;
+                }
+                if ((0, types_1.isUnpackedClass)(arg.type) &&
+                    arg.type.priv.tupleTypeArgs &&
+                    arg.type.priv.tupleTypeArgs.length === 1 &&
+                    arg.type.priv.tupleTypeArgs[0].isUnbounded) {
+                    srcUnboundedTupleType = arg.type.priv.tupleTypeArgs[0].type;
+                    return true;
+                }
+                return false;
+            });
+        };
+        let srcUnboundedTupleIndex = findUnboundedTupleIndex(0);
+        // Allow only one unpacked tuple that maps to a TypeVarTuple.
+        if (srcUnboundedTupleIndex >= 0) {
+            const secondUnboundedTupleIndex = findUnboundedTupleIndex(srcUnboundedTupleIndex + 1);
+            if (secondUnboundedTupleIndex >= 0) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), typeArgs[secondUnboundedTupleIndex].node);
             }
-            return false;
-        });
+        }
         if (srcUnboundedTupleType &&
             srcUnboundedTupleIndex >= 0 &&
             variadicIndex >= 0 &&
@@ -8500,7 +8500,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the function is returning a callable, don't eliminate unsolved
         // type vars within a union. There are legit uses for unsolved type vars
         // within a callable.
-        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloaded)(returnType)) {
+        if ((0, types_1.isFunctionOrOverloaded)(returnType)) {
             eliminateUnsolvedInUnions = false;
         }
         let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
@@ -11334,7 +11334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
                     }
                     else if (paramLimit === undefined && (0, types_1.isUnpackedClass)(typeArg.type)) {
-                        if (typeArg.type.priv.tupleTypeArgs?.some((typeArg) => (0, types_1.isTypeVarTuple)(typeArg.type) || typeArg.isUnbounded)) {
+                        if ((0, typeUtils_1.isUnboundedTupleClass)(typeArg.type)) {
                             noteSawUnpacked(typeArg);
                         }
                         validateTypeArg(typeArg, { allowUnpackedTuples: true });
@@ -13482,7 +13482,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             let skipInference = false;
-            if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloaded)(defaultValueType)) {
+            if ((0, types_1.isFunctionOrOverloaded)(defaultValueType)) {
                 // Do not infer parameter types that use a lambda or another function as a
                 // default value. We're likely to generate false positives in this case.
                 // It's not clear whether parameters should be positional-only or not.
@@ -13893,6 +13893,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return;
         }
         const exprTypeResult = getTypeOfExpression(node.d.expr);
+        let isIncomplete = exprTypeResult.isIncomplete;
         let exprType = exprTypeResult.type;
         const isAsync = node.parent && node.parent.nodeType === 58 /* ParseNodeType.With */ && !!node.parent.d.isAsync;
         if ((0, typeUtils_1.isOptionalType)(exprType)) {
@@ -13911,7 +13912,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const enterTypeResult = getTypeOfMagicMethodCall(subtype, enterMethodName, [], node.d.expr, 
                 /* inferenceContext */ undefined, enterDiag.createAddendum());
                 if (enterTypeResult) {
-                    return isAsync ? getTypeOfAwaitable(enterTypeResult.type, node.d.expr) : enterTypeResult.type;
+                    if (isAsync) {
+                        if (enterTypeResult.isIncomplete) {
+                            isIncomplete = true;
+                        }
+                        const asyncResult = getTypeOfAwaitable({ type: enterTypeResult.type }, node.d.expr);
+                        if (asyncResult.isIncomplete) {
+                            isIncomplete = true;
+                        }
+                        return asyncResult.type;
+                    }
+                    return enterTypeResult.type;
                 }
                 if (!isAsync) {
                     if (getTypeOfMagicMethodCall(subtype, '__aenter__', [], node.d.expr, 
@@ -13937,7 +13948,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const exitTypeResult = getTypeOfMagicMethodCall(subtype, exitMethodName, [anyArg, anyArg, anyArg], node.d.expr, 
                 /* inferenceContext */ undefined, exitDiag);
                 if (exitTypeResult) {
-                    return isAsync ? getTypeOfAwaitable(exitTypeResult.type, node.d.expr) : exitTypeResult.type;
+                    if (exitTypeResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    if (isAsync) {
+                        const asyncResult = getTypeOfAwaitable({ type: exitTypeResult.type }, node.d.expr);
+                        if (asyncResult.isIncomplete) {
+                            isIncomplete = true;
+                        }
+                        return asyncResult.type;
+                    }
+                    return exitTypeResult.type;
                 }
             }
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeNotUsableWith().format({ type: printType(subtype), method: exitMethodName }) +
@@ -13945,9 +13966,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return types_1.UnknownType.create();
         });
         if (node.d.target) {
-            assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete: exprTypeResult.isIncomplete }, node.d.target);
+            assignTypeToExpression(node.d.target, { type: scopedType, isIncomplete }, node.d.target);
         }
-        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
+        writeTypeCache(node, { type: scopedType, isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForImportAs(node) {
         if (isTypeCached(node)) {
@@ -14869,7 +14890,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.ClassType.isBuiltIn(classType, 'type') && typeArgs) {
                 if (typeArgs.length >= 1) {
                     // Treat type[function] as illegal.
-                    if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloaded)(typeArgs[0].type)) {
+                    if ((0, types_1.isFunctionOrOverloaded)(typeArgs[0].type)) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                         return { type: types_1.UnknownType.create() };
                     }
@@ -15421,7 +15442,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!tracker) {
             return type;
         }
-        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
+        if ((0, types_1.isFunctionOrOverloaded)(type)) {
             return (0, typeUtils_1.ensureSignaturesAreUnique)(type, tracker, node.start);
         }
         return type;
@@ -16931,13 +16952,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (errorNode &&
             selfClass &&
             (0, types_1.isClass)(selfClass) &&
+            !selfClass.priv.includeSubclasses &&
             member.isInstanceMember &&
             (0, types_1.isClass)(member.unspecializedClassType) &&
             (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
             (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
             const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
-            if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
-                !(0, types_1.isOverloaded)(subtype) &&
+            if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunctionOrOverloaded)(subtype) &&
                 (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
             }
@@ -17770,7 +17791,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 return true;
             }
-            else if ((0, types_1.isFunction)(concreteSrcType) || (0, types_1.isOverloaded)(concreteSrcType)) {
+            else if ((0, types_1.isFunctionOrOverloaded)(concreteSrcType)) {
                 // Is the destination a callback protocol (defined in PEP 544)?
                 const destCallbackType = getCallbackProtocolType(destType, recursionCount);
                 if (destCallbackType) {
@@ -17805,13 +17826,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Determine if the metaclass can be assigned to the object.
                 const metaclass = concreteSrcType.shared.effectiveMetaclass;
                 if (metaclass) {
-                    if ((0, types_1.isAnyOrUnknown)(metaclass)) {
-                        return true;
-                    }
-                    if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
-                    /* diag */ undefined, constraints, flags, recursionCount, 
-                    /* reportErrorsUsingObjType */ true)) {
-                        return true;
+                    if (!(0, types_1.isAnyOrUnknown)(metaclass)) {
+                        if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
+                        /* diag */ undefined, constraints, flags, recursionCount, 
+                        /* reportErrorsUsingObjType */ true)) {
+                            return true;
+                        }
                     }
                 }
             }
@@ -18083,10 +18103,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         }
                     }
-                    if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloaded)(srcSubtype)) {
-                        if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloaded)(destSubtype)) {
-                            return true;
-                        }
+                    if ((0, types_1.isFunctionOrOverloaded)(srcSubtype) && (0, types_1.isFunctionOrOverloaded)(destSubtype)) {
+                        return true;
                     }
                     return false;
                 });
@@ -18287,10 +18305,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
         }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
-        if (isLeftCallable !== isRightCallable) {
-            return false;
+        const isLeftCallable = (0, types_1.isFunctionOrOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunctionOrOverloaded)(rightType);
+        // If either type is a function, assume that it may be comparable. The other
+        // operand might be a callable object, an 'object' instance, etc. We could
+        // make this more precise for specific cases (e.g. if the other operand is
+        // None or a literal or an instance of a nominal class that doesn't override
+        // __call__ and is marked final, etc.), but coming up with a comprehensive
+        // list is probably not feasible.
+        if (isLeftCallable || isRightCallable) {
+            return true;
         }
         if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
             if ((0, types_1.isInstantiableClass)(rightType) ||
@@ -19281,7 +19305,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     // We also need to be careful with callback protocols.
                     if ((0, types_1.isClassInstance)(declaredSubtype) && types_1.ClassType.isProtocolClass(declaredSubtype)) {
-                        if ((0, types_1.isFunction)(assignedSubtype) || (0, types_1.isOverloaded)(assignedSubtype)) {
+                        if ((0, types_1.isFunctionOrOverloaded)(assignedSubtype)) {
                             return assignedSubtype;
                         }
                     }
@@ -19312,7 +19336,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
-        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloaded)(baseMethod)) {
+        if (!(0, types_1.isFunctionOrOverloaded)(baseMethod)) {
             diag.addMessage(localize_1.LocAddendum.overrideType().format({ type: printType(baseMethod) }));
             return false;
         }
@@ -19892,7 +19916,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // bound to its own __call__ method but the first parameter
                     // is annotated with its own callable type. This can lead to
                     // infinite recursion.
-                    if ((0, types_1.isFunction)(memberTypeFirstParamType) || (0, types_1.isOverloaded)(memberTypeFirstParamType)) {
+                    if ((0, types_1.isFunctionOrOverloaded)(memberTypeFirstParamType)) {
                         if ((0, types_1.isClassInstance)(firstParamType) && types_1.ClassType.isProtocolClass(firstParamType)) {
                             if (subDiag) {
                                 subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({