@zzzen/pyright-internal 1.2.0-dev.20230716 → 1.2.0-dev.20230723

package/dist/analyzer/typeEvaluator.js

@@ -175,7 +175,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let typeCache = new Map();
     let effectiveTypeCache = new Map();
     let expectedTypeCache = new Map();
-    let classTypeHooks = [];
+    let deferredClassCompletions = [];
     let cancellationToken;
     let isBasicTypesInitialized = false;
     let noneType;
@@ -1420,6 +1420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let classOrObjectBase;
         let memberAccessClass;
         let bindFunction = true;
+        let useDescriptorSetterType = false;
         switch (expression.nodeType) {
             case 38 /* Name */: {
                 const symbolWithScope = lookUpSymbolRecursive(expression, expression.value, /* honorCodeFlow */ true);
@@ -1460,6 +1461,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.isInstanceMember) {
                         bindFunction = false;
                     }
+                    useDescriptorSetterType = true;
                 }
                 else if ((0, types_1.isInstantiableClass)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseType, expression.memberName.value, 8 /* SkipInstanceVariables */ | 16 /* DeclaredTypesOnly */);
@@ -1505,7 +1507,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let declaredType = (_b = getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
             if (declaredType) {
                 // If it's a descriptor, we need to get the setter type.
-                if ((0, types_1.isClassInstance)(declaredType)) {
+                if (useDescriptorSetterType && (0, types_1.isClassInstance)(declaredType)) {
                     const setterInfo = (0, typeUtils_1.lookUpClassMember)(declaredType, '__set__');
                     const setter = setterInfo ? getTypeOfMember(setterInfo) : undefined;
                     if (setterInfo && setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
@@ -1908,7 +1910,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function isDiagnosticSuppressedForNode(node) {
         return (suppressedNodeStack.some((suppressedNode) => ParseTreeUtils.isNodeContainedWithin(node, suppressedNode)) ||
-            isSpeculativeModeInUse(node));
+            speculativeTypeTracker.isSpeculative(node, /* ignoreIfDiagnosticsAllowed */ true));
     }
     function addDiagnostic(diagLevel, rule, message, node, range) {
         if (diagLevel === 'none') {
@@ -2392,20 +2394,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // its bound type and a constrained TypeVar is expanded to its individual
     // constrained types). If conditionFilter is specified, conditions that
     // do not match will be ignored.
-    function mapSubtypesExpandTypeVars(type, conditionFilter, callback) {
+    function mapSubtypesExpandTypeVars(type, conditionFilter, callback, recursionCount = 0) {
         const newSubtypes = [];
         let typeChanged = false;
-        const expandSubtype = (unexpandedType) => {
+        function expandSubtype(unexpandedType, isLastSubtype) {
             let expandedType = (0, types_1.isUnion)(unexpandedType) ? unexpandedType : makeTopLevelTypeVarsConcrete(unexpandedType);
             expandedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedType);
-            (0, typeUtils_1.doForEachSubtype)(expandedType, (subtype) => {
+            (0, typeUtils_1.doForEachSubtype)(expandedType, (subtype, index, allSubtypes) => {
                 var _a;
                 if (conditionFilter) {
-                    if (!types_1.TypeCondition.isCompatible((0, typeUtils_1.getTypeCondition)(subtype), conditionFilter)) {
+                    const filteredType = applyConditionFilterToType(subtype, conditionFilter, recursionCount);
+                    if (!filteredType) {
                         return undefined;
                     }
+                    subtype = filteredType;
                 }
-                let transformedType = callback(subtype, unexpandedType);
+                let transformedType = callback(subtype, unexpandedType, isLastSubtype && index === allSubtypes.length - 1);
                 if (transformedType !== unexpandedType) {
                     typeChanged = true;
                 }
@@ -2419,14 +2423,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             });
-        };
+        }
         if ((0, types_1.isUnion)(type)) {
-            type.subtypes.forEach((subtype) => {
-                expandSubtype(subtype);
+            type.subtypes.forEach((subtype, index) => {
+                expandSubtype(subtype, index === type.subtypes.length - 1);
             });
         }
         else {
-            expandSubtype(type);
+            expandSubtype(type, /* isLastSubtype */ true);
         }
         if (!typeChanged) {
             return type;
@@ -2438,6 +2442,40 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return newType;
     }
+    function applyConditionFilterToType(type, conditionFilter, recursionCount) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return type;
+        }
+        recursionCount++;
+        // If the type has a condition associated with it, make sure it's compatible.
+        if (!types_1.TypeCondition.isCompatible((0, typeUtils_1.getTypeCondition)(type), conditionFilter)) {
+            return undefined;
+        }
+        // If the type is generic, see if any of its type arguments should be filtered.
+        // This is possible only in cases where the type parameter is covariant.
+        // TODO - handle functions and tuples
+        if ((0, types_1.isClass)(type) && type.typeArguments && !type.tupleTypeArguments) {
+            inferTypeParameterVarianceForClass(type);
+            let typeWasTransformed = false;
+            const filteredTypeArgs = type.typeArguments.map((typeArg, index) => {
+                const variance = types_1.TypeVarType.getVariance(type.details.typeParameters[index]);
+                if (variance !== 3 /* Covariant */) {
+                    return typeArg;
+                }
+                const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, conditionFilter, (expandedSubtype) => {
+                    return expandedSubtype;
+                }, recursionCount);
+                if (filteredTypeArg !== typeArg) {
+                    typeWasTransformed = true;
+                }
+                return filteredTypeArg;
+            });
+            if (typeWasTransformed) {
+                return types_1.ClassType.cloneForSpecialization(type, filteredTypeArgs, /* isTypeArgumentExplicit */ true);
+            }
+        }
+        return type;
+    }
     function markNamesAccessed(node, names) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const scope = ScopeUtils.getScopeForNode(node);
@@ -2814,7 +2852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // Verify that the name does not refer to a (non type alias) variable.
                     if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
                         let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
-                        if ((0, types_1.isClass)(type) && !type.includeSubclasses) {
+                        if ((0, types_1.isClass)(type) && !type.includeSubclasses && !symbol.hasTypedDeclarations()) {
                             // This check exempts class types that are created by calling
                             // NewType, NamedTuple, and by invoking a metaclass directly.
                             isAllowedTypeForVariable = true;
@@ -2892,13 +2930,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
         // This function applies only to variables, parameters, and imports, not to other
         // types of symbols.
-        if (!symbolWithScope.symbol
-            .getDeclarations()
-            .every((decl) => decl.type === 1 /* Variable */ ||
+        const decls = symbolWithScope.symbol.getDeclarations();
+        if (!decls.every((decl) => decl.type === 1 /* Variable */ ||
             decl.type === 2 /* Parameter */ ||
             decl.type === 8 /* Alias */)) {
             return undefined;
         }
+        // If the symbol is modified in scopes other than the one in which it is
+        // declared (e.g. through a nonlocal or global binding), it is not eligible
+        // for code flow analysis.
+        if (!decls.every((decl) => decl.type === 2 /* Parameter */ ||
+            ScopeUtils.getScopeForNode(decl.node) === symbolWithScope.scope)) {
+            return undefined;
+        }
         // If the symbol is a variable captured by an inner function
         // or lambda, see if we can infer the type from the outer scope.
         const scopeHierarchy = ScopeUtils.getScopeHierarchy(node, symbolWithScope.scope);
@@ -2934,7 +2978,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return !codeFlowEngine.isFlowNodeReachable(declCodeFlowNode, innerScopeCodeFlowNode, 
                         /* ignoreNoReturn */ true);
                     })) {
-                        return getFlowTypeOfReference(node, symbolWithScope.symbol.id, effectiveType, innerScopeNode);
+                        let typeAtStart = effectiveType;
+                        if (symbolWithScope.symbol.isInitiallyUnbound()) {
+                            typeAtStart = types_1.UnboundType.create();
+                        }
+                        return getFlowTypeOfReference(node, symbolWithScope.symbol.id, typeAtStart, innerScopeNode);
                     }
                 }
             }
@@ -3290,7 +3338,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 baseType = objectType;
             }
         }
-        const getTypeOfNoneBase = (subtype) => {
+        function getTypeOfNoneBase(subtype) {
             if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
                 if (types_1.TypeBase.isInstance(subtype)) {
                     return getTypeOfObjectMember(node.memberName, types_1.ClassType.cloneAsInstance(noneType), memberName, usage, diag);
@@ -3300,7 +3348,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             return undefined;
-        };
+        }
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
             baseType = makeTopLevelTypeVarsConcrete(baseType);
         }
@@ -3346,11 +3394,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (baseType.details.recursiveTypeAliasName) {
                     return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
                 }
-                return getTypeOfMemberAccessWithBaseType(node, {
-                    type: makeTopLevelTypeVarsConcrete(baseType),
-                    bindToType: baseType,
-                    isIncomplete,
-                }, usage, 0 /* None */);
+                if (!baseType.details.isVariadic) {
+                    return getTypeOfMemberAccessWithBaseType(node, {
+                        type: makeTopLevelTypeVarsConcrete(baseType),
+                        bindToType: baseType,
+                        isIncomplete,
+                    }, usage, 0 /* None */);
+                }
+                break;
             }
             case 7 /* Class */: {
                 if (types_1.TypeBase.isInstantiable(baseType)) {
@@ -3821,7 +3872,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     type: types_1.ClassType.isClassProperty(lookupClass)
                                         ? baseTypeClass
                                         : isAccessedThroughObject
-                                            ? bindToType || types_1.ClassType.cloneAsInstance(baseTypeClass)
+                                            ? bindToType !== null && bindToType !== void 0 ? bindToType : types_1.ClassType.cloneAsInstance(baseTypeClass)
                                             : types_1.NoneType.createInstance(),
                                 },
                             },
@@ -3970,8 +4021,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this function is an instance member (e.g. a lambda that was
                 // assigned to an instance variable), don't perform any binding.
                 if (!isAccessedThroughObject || (memberInfo && !memberInfo.isInstanceMember)) {
+                    let effectiveBindToType = bindToType;
+                    if (bindToType && !(0, typeUtils_1.isInstantiableMetaclass)(baseTypeClass)) {
+                        // If bindToType is an instantiable class or TypeVar but we're targeting
+                        // an instance method (in a non-metaclass), we need to convert
+                        // the bindToType to an instance.
+                        const targetMethod = (0, types_1.isFunction)(concreteSubtype)
+                            ? concreteSubtype
+                            : concreteSubtype.overloads[0];
+                        if (types_1.FunctionType.isInstanceMethod(targetMethod) && !types_1.TypeBase.isInstance(bindToType)) {
+                            effectiveBindToType = (0, typeUtils_1.convertToInstance)(bindToType);
+                        }
+                    }
                     return bindFunctionToClassOrObject(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, 
-                    /* recursionCount */ undefined, treatConstructorAsClassMember, bindToType);
+                    /* recursionCount */ undefined, treatConstructorAsClassMember, effectiveBindToType);
                 }
             }
             if (usage.method === 'set') {
@@ -5263,6 +5326,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
+        // Check for the use of `type(x)` within a type annotation. This isn't
+        // allowed, and it's a common mistake, so we want to emit a diagnostic
+        // that guides the user to the right solution.
         if ((flags & 256 /* ExpectingTypeAnnotation */) !== 0 &&
             node.leftExpression.nodeType === 38 /* Name */ &&
             node.leftExpression.value === 'type') {
@@ -5324,20 +5390,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
-                // Check for an attempt to invoke an abstract static or class method.
-                if ((0, types_1.isFunction)(baseTypeResult.type) &&
-                    baseTypeResult.type.boundToType &&
-                    (0, types_1.isInstantiableClass)(baseTypeResult.type.boundToType) &&
-                    !baseTypeResult.type.boundToType.includeSubclasses) {
-                    if (types_1.FunctionType.isAbstractMethod(baseTypeResult.type)) {
-                        if (types_1.FunctionType.isStaticMethod(baseTypeResult.type) ||
-                            types_1.FunctionType.isClassMethod(baseTypeResult.type)) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
-                                method: baseTypeResult.type.details.name,
-                            }), node.leftExpression);
-                        }
-                    }
-                }
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
                 /* skipUnknownArgCheck */ false, inferenceContext);
@@ -5776,7 +5828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If there were multiple possible matches, evaluate the type as
             // Unknown, but include the "possible types" to allow for completion
             // suggestions.
-            if (!isDefinitiveMatchFound) {
+            if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
                 possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
                 // Did the filtering produce a single result? If so, we're done.
                 if (possibleMatchResults.length === 1) {
@@ -5984,24 +6036,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
         }
-        // Create a helper function that evaluates the overload that matches
-        // the arg/param lists.
-        function evaluateUsingLastMatchingOverload(skipUnknownArgCheck) {
-            // Find the match with the largest overload index (i.e. the last overload
-            // that was in the overload list).
-            const lastMatch = filteredMatchResults.reduce((previous, current) => {
-                return current.overloadIndex > previous.overloadIndex ? current : previous;
+        // Create a helper function that evaluates the overload that best
+        // matches the arg/param lists.
+        function evaluateUsingBestMatchingOverload(skipUnknownArgCheck) {
+            // Find the match with the smallest argument match score. If there
+            // are more than one with the same score, use the one with the
+            // largest index. Later overloads tend to be more general.
+            const bestMatch = filteredMatchResults.reduce((previous, current) => {
+                if (current.argumentMatchScore === previous.argumentMatchScore) {
+                    return current.overloadIndex > previous.overloadIndex ? current : previous;
+                }
+                return current.argumentMatchScore < previous.argumentMatchScore ? current : previous;
             });
             const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
-            effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(lastMatch.overload));
+            effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(bestMatch.overload));
             effectiveTypeVarContext.unlock();
-            return validateFunctionArgumentTypesWithContext(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            return validateFunctionArgumentTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
         }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
         // will provide a clearer error message.
         if (filteredMatchResults.length === 1) {
-            return evaluateUsingLastMatchingOverload(/* skipUnknownArgCheck */ false);
+            return evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ false);
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         let isTypeIncomplete = !!typeResult.isIncomplete;
@@ -6044,7 +6100,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // in speculative mode because it's very expensive, and we're going to
         // suppress the diagnostic anyway.
         if (!isDiagnosticSuppressedForNode(errorNode) && !isTypeIncomplete) {
-            const result = evaluateUsingLastMatchingOverload(/* skipUnknownArgCheck */ true);
+            const result = evaluateUsingBestMatchingOverload(/* skipUnknownArgCheck */ true);
             // Replace the result with an unknown type since we don't know
             // what overload should have been used.
             result.returnType = types_1.UnknownType.create();
@@ -6120,334 +6176,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
         let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, 
-        /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype) => {
-            var _a, _b, _c, _d, _e, _f, _g;
-            switch (expandedSubtype.category) {
-                case 1 /* Unknown */:
-                case 2 /* Any */: {
-                    // Touch all of the args so they're marked accessed. Don't bother
-                    // doing this if the call type is incomplete because this will need
-                    // to be done again once it is complete.
-                    if (!callTypeResult.isIncomplete) {
-                        argList.forEach((arg) => {
-                            if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                                getTypeOfArgument(arg);
-                            }
-                        });
-                    }
-                    return expandedSubtype;
-                }
-                case 5 /* Function */: {
-                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
-                            type: printType(expandedSubtype),
-                        }), errorNode);
-                        argumentErrors = true;
-                        return undefined;
-                    }
-                    // The stdlib collections/__init__.pyi stub file defines namedtuple
-                    // as a function rather than a class, so we need to check for it here.
-                    if (expandedSubtype.details.builtInName === 'namedtuple') {
-                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUntypedNamedTuple, diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.Localizer.Diagnostic.namedTupleNoTypes(), errorNode);
-                        return (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
-                        /* includesTypes */ false);
-                    }
-                    // Handle the NewType specially, replacing the normal return type.
-                    if (expandedSubtype.details.builtInName === 'NewType') {
-                        return createNewType(errorNode, argList);
-                    }
-                    let effectiveTypeVarContext = typeVarContext;
-                    if (!effectiveTypeVarContext) {
-                        // If a typeVarContext wasn't provided by the caller, allocate one here.
-                        effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedSubtype));
-                        // There are certain cases, such as with super().__new__(cls) calls where
-                        // the call is a constructor but the proper TypeVar scope has been lost.
-                        // We'll add a wildcard TypeVar scope here. This is a bit of a hack and
-                        // we may need to revisit this in the future.
-                        if (types_1.FunctionType.isConstructorMethod(expandedSubtype)) {
-                            effectiveTypeVarContext.addSolveForScope(types_1.WildcardTypeVarScopeId);
-                        }
-                    }
-                    const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
-                    if (functionResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
-                    if (functionResult.argumentErrors) {
-                        argumentErrors = true;
-                    }
-                    else {
-                        specializedInitSelfType = functionResult.specializedInitSelfType;
-                        // Call the function transform logic to handle special-cased functions.
-                        const transformed = (0, functionTransform_1.applyFunctionTransform)(evaluatorInterface, errorNode, argList, expandedSubtype, {
-                            argumentErrors: functionResult.argumentErrors,
-                            returnType: (_a = functionResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(isTypeIncomplete),
-                            isTypeIncomplete,
-                        });
-                        functionResult.returnType = transformed.returnType;
-                        if (transformed.isTypeIncomplete) {
-                            isTypeIncomplete = true;
-                        }
-                        if (transformed.argumentErrors) {
-                            argumentErrors = true;
-                        }
-                    }
-                    if (expandedSubtype.details.builtInName === '__import__') {
-                        // For the special __import__ type, we'll override the return type to be "Any".
-                        // This is required because we don't know what module was imported, and we don't
-                        // want to fail type checks when accessing members of the resulting module type.
-                        return types_1.AnyType.create();
-                    }
-                    return functionResult.returnType;
-                }
-                case 6 /* OverloadedFunction */: {
-                    // Handle the 'cast' call as a special case.
-                    if (expandedSubtype.overloads[0].details.builtInName === 'cast' && argList.length === 2) {
-                        return evaluateCastCall(argList, errorNode);
-                    }
-                    const functionResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
-                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
-                    if (functionResult.isTypeIncomplete) {
-                        isTypeIncomplete = true;
-                    }
-                    if (functionResult.argumentErrors) {
-                        argumentErrors = true;
-                    }
-                    else {
-                        specializedInitSelfType = functionResult.specializedInitSelfType;
-                        // Call the function transform logic to handle special-cased functions.
-                        const transformed = (0, functionTransform_1.applyFunctionTransform)(evaluatorInterface, errorNode, argList, expandedSubtype, {
-                            argumentErrors: functionResult.argumentErrors,
-                            returnType: (_b = functionResult.returnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(isTypeIncomplete),
-                            isTypeIncomplete,
-                        });
-                        functionResult.returnType = transformed.returnType;
-                        if (transformed.isTypeIncomplete) {
-                            isTypeIncomplete = true;
-                        }
-                        if (transformed.argumentErrors) {
-                            argumentErrors = true;
-                        }
-                    }
-                    return (_c = functionResult.returnType) !== null && _c !== void 0 ? _c : types_1.UnknownType.create();
-                }
-                case 7 /* Class */: {
-                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
-                        if (expandedSubtype.literalValue !== undefined) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.literalNotCallable(), errorNode);
-                            argumentErrors = true;
-                            return types_1.UnknownType.create();
-                        }
-                        if (types_1.ClassType.isBuiltIn(expandedSubtype)) {
-                            const className = expandedSubtype.aliasName || expandedSubtype.details.name;
-                            if (className === 'type') {
-                                // Validate the constructor arguments.
-                                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
-                                // Handle the 'type' call specially.
-                                if (argList.length === 1) {
-                                    // The one-parameter form of "type" returns the class
-                                    // for the specified object.
-                                    const argType = getTypeOfArgument(argList[0]).type;
-                                    return (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
-                                        if ((0, types_1.isClassInstance)(subtype) ||
-                                            ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
-                                            (0, types_1.isNoneInstance)(subtype)) {
-                                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
-                                        }
-                                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
-                                            return types_1.FunctionType.cloneAsInstantiable(subtype);
-                                        }
-                                        return types_1.AnyType.create();
-                                    });
-                                }
-                                else if (argList.length >= 2) {
-                                    // The two-parameter form of "type" returns a new class type
-                                    // built from the specified base types.
-                                    return createType(errorNode, argList) || types_1.AnyType.create();
-                                }
-                                // If the parameter to type() is not statically known,
-                                // fall back to Any.
-                                return types_1.AnyType.create();
-                            }
-                            if (className === 'TypeVar') {
-                                return createTypeVarType(errorNode, expandedSubtype, argList);
-                            }
-                            if (className === 'TypeVarTuple') {
-                                return createTypeVarTupleType(errorNode, expandedSubtype, argList);
-                            }
-                            if (className === 'ParamSpec') {
-                                return createParamSpecType(errorNode, expandedSubtype, argList);
-                            }
-                            if (className === 'TypeAliasType') {
-                                const newTypeAlias = createTypeAliasType(errorNode, argList);
-                                if (newTypeAlias) {
-                                    return newTypeAlias;
-                                }
-                            }
-                            if (className === 'NamedTuple') {
-                                return (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
-                                /* includesTypes */ true);
-                            }
-                            if (className === 'NewType') {
-                                return createNewType(errorNode, argList);
-                            }
-                            if (className === 'Protocol' ||
-                                className === 'Generic' ||
-                                className === 'Callable' ||
-                                className === 'Concatenate' ||
-                                className === 'Type') {
-                                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
-                                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
-                                return types_1.AnyType.create();
-                            }
-                            if ((0, types_1.isClass)(unexpandedSubtype) && (0, enums_1.isKnownEnumType)(className)) {
-                                return ((_d = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create());
-                            }
-                            if (className === 'TypedDict') {
-                                return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
-                            }
-                            if (className === 'auto' && argList.length === 0) {
-                                return (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode);
-                            }
-                        }
-                        if (types_1.ClassType.supportsAbstractMethods(expandedSubtype)) {
-                            const abstractMethods = getAbstractMethods(expandedSubtype);
-                            if (abstractMethods.length > 0 &&
-                                !expandedSubtype.includeSubclasses &&
-                                !(0, types_1.isTypeVar)(unexpandedSubtype)) {
-                                // If the class is abstract, it can't be instantiated.
-                                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                                const errorsToDisplay = 2;
-                                abstractMethods.forEach((abstractMethod, index) => {
-                                    if (index === errorsToDisplay) {
-                                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstractMore().format({
-                                            count: abstractMethods.length - errorsToDisplay,
-                                        }));
-                                    }
-                                    else if (index < errorsToDisplay) {
-                                        if ((0, types_1.isInstantiableClass)(abstractMethod.classType)) {
-                                            const className = abstractMethod.classType.details.name;
-                                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstract().format({
-                                                type: className,
-                                                name: abstractMethod.symbolName,
-                                            }));
-                                        }
-                                    }
-                                });
-                                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
-                                    .reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateAbstract().format({
-                                    type: expandedSubtype.details.name,
-                                }) + diagAddendum.getString(), errorNode);
-                            }
-                        }
-                        if (types_1.ClassType.isProtocolClass(expandedSubtype) && !expandedSubtype.includeSubclasses) {
-                            // If the class is a protocol, it can't be instantiated.
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateProtocol().format({
-                                type: expandedSubtype.details.name,
-                            }), errorNode);
-                        }
-                        // Assume this is a call to the constructor.
-                        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
-                        (0, collectionUtils_1.appendArray)(overloadsUsedForCall, constructorResult.overloadsUsedForCall);
-                        if (constructorResult.argumentErrors) {
-                            argumentErrors = true;
-                        }
-                        if (constructorResult.isTypeIncomplete) {
-                            isTypeIncomplete = true;
-                        }
-                        let returnType = constructorResult.returnType;
-                        // If the expandedSubtype originated from a TypeVar, convert
-                        // the constructed type back to the TypeVar. For example, if
-                        // we have `cls: Type[_T]` followed by `_T()`.
-                        if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
-                            returnType = (0, typeUtils_1.convertToInstance)(unexpandedSubtype);
-                        }
-                        // If we instantiated a type, transform it into a class.
-                        // This can happen if someone directly instantiates a metaclass
-                        // deriving from type.
-                        if (returnType &&
-                            (0, types_1.isClassInstance)(returnType) &&
-                            returnType.details.mro.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'type'))) {
-                            let newClassName = '__class_' + returnType.details.name;
-                            if (argList.length === 3) {
-                                const firstArgType = getTypeOfArgument(argList[0]).type;
-                                if ((0, types_1.isClassInstance)(firstArgType) &&
-                                    types_1.ClassType.isBuiltIn(firstArgType, 'str') &&
-                                    typeof firstArgType.literalValue === 'string') {
-                                    newClassName = firstArgType.literalValue;
-                                }
-                            }
-                            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
-                            newClassType.details.baseClasses.push(getBuiltInType(errorNode, 'object'));
-                            newClassType.details.effectiveMetaclass = expandedSubtype;
-                            (0, typeUtils_1.computeMroLinearization)(newClassType);
-                            return newClassType;
-                        }
-                        return returnType;
-                    }
-                    else {
-                        const memberType = (_e = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
-                        /* usage */ undefined, 
-                        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _e === void 0 ? void 0 : _e.type;
-                        if (memberType) {
-                            const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
-                            (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
-                            if (functionResult.argumentErrors) {
-                                argumentErrors = true;
-                            }
-                            if ((0, types_1.isTypeVar)(unexpandedSubtype) &&
-                                types_1.TypeBase.isInstantiable(unexpandedSubtype) &&
-                                (0, types_1.isClass)(expandedSubtype) &&
-                                types_1.ClassType.isBuiltIn(expandedSubtype, 'type')) {
-                                // Handle the case where a Type[T] is being called. We presume this
-                                // will instantiate an object of type T.
-                                return (0, typeUtils_1.convertToInstance)(unexpandedSubtype);
-                            }
-                            return (_f = functionResult.returnType) !== null && _f !== void 0 ? _f : types_1.UnknownType.create();
-                        }
-                        if (!memberType || !(0, types_1.isAnyOrUnknown)(memberType)) {
-                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
-                                type: printType(expandedSubtype),
-                            }), errorNode);
-                        }
-                        return types_1.UnknownType.create();
-                    }
+        /* conditionFilter */ undefined, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
+            return useSpeculativeMode(isLastIteration ? undefined : errorNode, () => {
+                const callResult = validateCallArgumentsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                if (callResult.argumentErrors) {
+                    argumentErrors = true;
                 }
-                case 3 /* None */: {
-                    if (types_1.TypeBase.isInstantiable(expandedSubtype)) {
-                        if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
-                            const functionResult = validateCallArguments(errorNode, argList, { type: noneType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
-                            if (functionResult.isTypeIncomplete) {
-                                isTypeIncomplete = true;
-                            }
-                            if (functionResult.argumentErrors) {
-                                argumentErrors = true;
-                            }
-                        }
-                        return types_1.NoneType.createInstance();
-                    }
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
-                    return undefined;
+                if (callResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
                 }
-                // TypeVars should have been expanded in most cases,
-                // but we still need to handle the case of Type[T] where
-                // T is a constrained type that contains a union. We also
-                // need to handle recursive type aliases.
-                case 10 /* TypeVar */: {
-                    expandedSubtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedSubtype);
-                    const callResult = validateCallArguments(errorNode, argList, { type: expandedSubtype }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                if (callResult.overloadsUsedForCall) {
                     (0, collectionUtils_1.appendArray)(overloadsUsedForCall, callResult.overloadsUsedForCall);
-                    if (callResult.argumentErrors) {
-                        argumentErrors = true;
-                    }
-                    return (_g = callResult.returnType) !== null && _g !== void 0 ? _g : types_1.UnknownType.create();
-                }
-                case 8 /* Module */: {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleNotCallable(), errorNode);
-                    return undefined;
                 }
-            }
-            return undefined;
+                specializedInitSelfType = callResult.specializedInitSelfType;
+                return callResult.returnType;
+            }, {
+                allowDiagnostics: true,
+            });
         });
         // If we ended up with a "Never" type because all code paths returned
         // undefined due to argument errors, transform the result into an Unknown
@@ -6463,10 +6208,350 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall,
         };
     }
+    function validateCallArgumentsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        switch (expandedCallType.category) {
+            case 4 /* Never */:
+            case 1 /* Unknown */:
+            case 2 /* Any */: {
+                // Touch all of the args so they're marked accessed. Don't bother
+                // doing this if the call type is incomplete because this will need
+                // to be done again once it is complete.
+                if (!isCallTypeIncomplete) {
+                    argList.forEach((arg) => {
+                        if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
+                            getTypeOfArgument(arg);
+                        }
+                    });
+                }
+                return { returnType: expandedCallType };
+            }
+            case 5 /* Function */: {
+                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+            }
+            case 6 /* OverloadedFunction */: {
+                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+            }
+            case 7 /* Class */: {
+                if (types_1.TypeBase.isInstantiable(expandedCallType)) {
+                    return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext);
+                }
+                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+            }
+            case 3 /* None */: {
+                if (types_1.TypeBase.isInstantiable(expandedCallType)) {
+                    if (noneType && (0, types_1.isInstantiableClass)(noneType)) {
+                        const callResult = validateCallForInstantiableClass(errorNode, argList, noneType, noneType, skipUnknownArgCheck, inferenceContext);
+                        return { ...callResult, returnType: types_1.NoneType.createInstance() };
+                    }
+                    return { returnType: types_1.NoneType.createInstance() };
+                }
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportOptionalCall, diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.Localizer.Diagnostic.noneNotCallable(), errorNode);
+                return { argumentErrors: true };
+            }
+            // TypeVars should have been expanded in most cases,
+            // but we still need to handle the case of Type[T] where
+            // T is a constrained type that contains a union. We also
+            // need to handle recursive type aliases.
+            case 10 /* TypeVar */: {
+                return validateCallArguments(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+            }
+            case 8 /* Module */: {
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.moduleNotCallable(), errorNode);
+                return { argumentErrors: true };
+            }
+        }
+        return { argumentErrors: true };
+    }
+    function validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+        var _a;
+        if (types_1.TypeBase.isInstantiable(expandedCallType)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.callableNotInstantiable().format({
+                type: printType(expandedCallType),
+            }), errorNode);
+            return { returnType: undefined, argumentErrors: true };
+        }
+        // Check for an attempt to invoke an abstract static or class method.
+        if (expandedCallType.boundToType &&
+            (0, types_1.isInstantiableClass)(expandedCallType.boundToType) &&
+            !expandedCallType.boundToType.includeSubclasses) {
+            if (types_1.FunctionType.isAbstractMethod(expandedCallType)) {
+                if (types_1.FunctionType.isStaticMethod(expandedCallType) || types_1.FunctionType.isClassMethod(expandedCallType)) {
+                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
+                        method: expandedCallType.details.name,
+                    }), errorNode.nodeType === 9 /* Call */ ? errorNode.leftExpression : errorNode);
+                }
+            }
+        }
+        // The stdlib collections/__init__.pyi stub file defines namedtuple
+        // as a function rather than a class, so we need to check for it here.
+        if (expandedCallType.details.builtInName === 'namedtuple') {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUntypedNamedTuple, diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.Localizer.Diagnostic.namedTupleNoTypes(), errorNode);
+            return {
+                returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
+            };
+        }
+        // Handle the NewType specially, replacing the normal return type.
+        if (expandedCallType.details.builtInName === 'NewType') {
+            return { returnType: createNewType(errorNode, argList) };
+        }
+        let effectiveTypeVarContext = typeVarContext;
+        if (!effectiveTypeVarContext) {
+            // If a typeVarContext wasn't provided by the caller, allocate one here.
+            effectiveTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(expandedCallType));
+        }
+        const functionResult = validateFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        let isTypeIncomplete = !!functionResult.isTypeIncomplete;
+        let returnType = functionResult.returnType;
+        let argumentErrors = !!functionResult.argumentErrors;
+        if (!argumentErrors) {
+            // Call the function transform logic to handle special-cased functions.
+            const transformed = (0, functionTransform_1.applyFunctionTransform)(evaluatorInterface, errorNode, argList, expandedCallType, {
+                argumentErrors: !!functionResult.argumentErrors,
+                returnType: (_a = functionResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(isTypeIncomplete),
+                isTypeIncomplete,
+            });
+            returnType = transformed.returnType;
+            if (transformed.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            if (transformed.argumentErrors) {
+                argumentErrors = true;
+            }
+        }
+        if (expandedCallType.details.builtInName === '__import__') {
+            // For the special __import__ type, we'll override the return type to be "Any".
+            // This is required because we don't know what module was imported, and we don't
+            // want to fail type checks when accessing members of the resulting module type.
+            returnType = types_1.AnyType.create();
+        }
+        return {
+            returnType,
+            isTypeIncomplete,
+            argumentErrors,
+            overloadsUsedForCall: functionResult.overloadsUsedForCall,
+            specializedInitSelfType: functionResult.specializedInitSelfType,
+        };
+    }
+    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+        var _a, _b;
+        // Handle the 'cast' call as a special case.
+        if (expandedCallType.overloads[0].details.builtInName === 'cast' && argList.length === 2) {
+            return { returnType: evaluateCastCall(argList, errorNode) };
+        }
+        const callResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+        let isTypeIncomplete = !!callResult.isTypeIncomplete;
+        let argumentErrors = !!callResult.argumentErrors;
+        if (!argumentErrors) {
+            // Call the function transform logic to handle special-cased functions.
+            const transformed = (0, functionTransform_1.applyFunctionTransform)(evaluatorInterface, errorNode, argList, expandedCallType, {
+                argumentErrors: !!callResult.argumentErrors,
+                returnType: (_b = callResult.returnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(isTypeIncomplete),
+                isTypeIncomplete,
+            });
+            returnType = transformed.returnType;
+            if (transformed.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            if (transformed.argumentErrors) {
+                argumentErrors = true;
+            }
+        }
+        return {
+            returnType,
+            isTypeIncomplete,
+            argumentErrors,
+            overloadsUsedForCall: callResult.overloadsUsedForCall,
+            specializedInitSelfType: callResult.specializedInitSelfType,
+        };
+    }
+    function validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext) {
+        var _a;
+        if (expandedCallType.literalValue !== undefined) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.literalNotCallable(), errorNode);
+            return { returnType: types_1.UnknownType.create(), argumentErrors: true };
+        }
+        if (types_1.ClassType.isBuiltIn(expandedCallType)) {
+            const className = expandedCallType.aliasName || expandedCallType.details.name;
+            if (className === 'type') {
+                // Validate the constructor arguments.
+                (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
+                // Handle the 'type' call specially.
+                if (argList.length === 1) {
+                    // The one-parameter form of "type" returns the class
+                    // for the specified object.
+                    const argType = getTypeOfArgument(argList[0]).type;
+                    const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
+                        if ((0, types_1.isClassInstance)(subtype) ||
+                            ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
+                            (0, types_1.isNoneInstance)(subtype)) {
+                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
+                        }
+                        else if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
+                            return types_1.FunctionType.cloneAsInstantiable(subtype);
+                        }
+                        return types_1.AnyType.create();
+                    });
+                    return { returnType };
+                }
+                if (argList.length >= 2) {
+                    // The two-parameter form of "type" returns a new class type
+                    // built from the specified base types.
+                    return { returnType: createType(errorNode, argList) || types_1.AnyType.create() };
+                }
+                // If the parameter to type() is not statically known,
+                // fall back to Any.
+                return { returnType: types_1.AnyType.create() };
+            }
+            if (className === 'TypeVar') {
+                return {
+                    returnType: createTypeVarType(errorNode, expandedCallType, argList),
+                };
+            }
+            if (className === 'TypeVarTuple') {
+                return {
+                    returnType: createTypeVarTupleType(errorNode, expandedCallType, argList),
+                };
+            }
+            if (className === 'ParamSpec') {
+                return {
+                    returnType: createParamSpecType(errorNode, expandedCallType, argList),
+                };
+            }
+            if (className === 'TypeAliasType') {
+                const newTypeAlias = createTypeAliasType(errorNode, argList);
+                if (newTypeAlias) {
+                    return { returnType: newTypeAlias };
+                }
+            }
+            if (className === 'NamedTuple') {
+                return {
+                    returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
+                };
+            }
+            if (className === 'NewType') {
+                return { returnType: createNewType(errorNode, argList) };
+            }
+            if (className === 'Protocol' ||
+                className === 'Generic' ||
+                className === 'Callable' ||
+                className === 'Concatenate' ||
+                className === 'Type') {
+                const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeNotIntantiable().format({ type: className }), errorNode);
+                return { returnType: types_1.AnyType.create() };
+            }
+            if ((0, types_1.isClass)(unexpandedCallType) && (0, enums_1.isKnownEnumType)(className)) {
+                return {
+                    returnType: (_a = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedCallType, argList)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(),
+                };
+            }
+            if (className === 'TypedDict') {
+                return { returnType: (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedCallType, argList) };
+            }
+            if (className === 'auto' && argList.length === 0) {
+                return { returnType: (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode) };
+            }
+        }
+        if (types_1.ClassType.supportsAbstractMethods(expandedCallType)) {
+            const abstractMethods = getAbstractMethods(expandedCallType);
+            if (abstractMethods.length > 0 && !expandedCallType.includeSubclasses && !(0, types_1.isTypeVar)(unexpandedCallType)) {
+                // If the class is abstract, it can't be instantiated.
+                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                const errorsToDisplay = 2;
+                abstractMethods.forEach((abstractMethod, index) => {
+                    if (index === errorsToDisplay) {
+                        diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstractMore().format({
+                            count: abstractMethods.length - errorsToDisplay,
+                        }));
+                    }
+                    else if (index < errorsToDisplay) {
+                        if ((0, types_1.isInstantiableClass)(abstractMethod.classType)) {
+                            const className = abstractMethod.classType.details.name;
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.memberIsAbstract().format({
+                                type: className,
+                                name: abstractMethod.symbolName,
+                            }));
+                        }
+                    }
+                });
+                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateAbstract().format({
+                    type: expandedCallType.details.name,
+                }) + diagAddendum.getString(), errorNode);
+            }
+        }
+        if (types_1.ClassType.isProtocolClass(expandedCallType) && !expandedCallType.includeSubclasses) {
+            // If the class is a protocol, it can't be instantiated.
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.instantiateProtocol().format({
+                type: expandedCallType.details.name,
+            }), errorNode);
+        }
+        // Assume this is a call to the constructor.
+        const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedCallType, skipUnknownArgCheck, inferenceContext);
+        const overloadsUsedForCall = constructorResult.overloadsUsedForCall;
+        const argumentErrors = constructorResult.argumentErrors;
+        const isTypeIncomplete = constructorResult.isTypeIncomplete;
+        let returnType = constructorResult.returnType;
+        // If the expandedCallType originated from a TypeVar, convert
+        // the constructed type back to the TypeVar. For example, if
+        // we have `cls: Type[_T]` followed by `_T()`.
+        if ((0, types_1.isTypeVar)(unexpandedCallType)) {
+            returnType = (0, typeUtils_1.convertToInstance)(unexpandedCallType);
+        }
+        // If we instantiated a type, transform it into a class.
+        // This can happen if someone directly instantiates a metaclass
+        // deriving from type.
+        if (returnType &&
+            (0, types_1.isClassInstance)(returnType) &&
+            returnType.details.mro.some((baseClass) => (0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'type'))) {
+            let newClassName = '__class_' + returnType.details.name;
+            if (argList.length === 3) {
+                const firstArgType = getTypeOfArgument(argList[0]).type;
+                if ((0, types_1.isClassInstance)(firstArgType) &&
+                    types_1.ClassType.isBuiltIn(firstArgType, 'str') &&
+                    typeof firstArgType.literalValue === 'string') {
+                    newClassName = firstArgType.literalValue;
+                }
+            }
+            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
+            newClassType.details.baseClasses.push(getBuiltInType(errorNode, 'object'));
+            newClassType.details.effectiveMetaclass = expandedCallType;
+            (0, typeUtils_1.computeMroLinearization)(newClassType);
+            returnType = newClassType;
+        }
+        return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
+    }
+    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        var _a, _b;
+        const memberType = (_a = getTypeOfObjectMember(errorNode, expandedCallType, '__call__', 
+        /* usage */ undefined, 
+        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _a === void 0 ? void 0 : _a.type;
+        if (!memberType) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.objectNotCallable().format({
+                type: printType(expandedCallType),
+            }), errorNode);
+            return { returnType: types_1.UnknownType.create(), argumentErrors: true };
+        }
+        const callResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+        let returnType = (_b = callResult.returnType) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+        if ((0, types_1.isTypeVar)(unexpandedCallType) &&
+            types_1.TypeBase.isInstantiable(unexpandedCallType) &&
+            (0, types_1.isClass)(expandedCallType) &&
+            types_1.ClassType.isBuiltIn(expandedCallType, 'type')) {
+            // Handle the case where a Type[T] is being called. We presume this
+            // will instantiate an object of type T.
+            returnType = (0, typeUtils_1.convertToInstance)(unexpandedCallType);
+        }
+        return {
+            returnType,
+            argumentErrors: callResult.argumentErrors,
+            overloadsUsedForCall: callResult.overloadsUsedForCall,
+        };
+    }
     // Evaluates the type of the "cast" call.
     function evaluateCastCall(argList, errorNode) {
         // Verify that the cast is necessary.
-        const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
+        const castToType = getTypeOfArgumentExpectingType(argList[0], { enforceTypeAnnotationRules: true }).type;
         const castFromType = getTypeOfArgument(argList[1]).type;
         if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
             if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
@@ -7328,6 +7413,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             paramSpecArgList,
             activeParam,
             relevance,
+            argumentMatchScore: 0,
         };
     }
     // After having matched arguments with parameters, this function evaluates the
@@ -7403,7 +7489,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
-                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
+                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
+                        unknownIfNotFound: true,
+                    });
                 }
             }
             else if ((0, types_1.isFunction)(effectiveReturnType)) {
@@ -7426,6 +7514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
+        let argumentMatchScore = 0;
         let specializedInitSelfType;
         let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
@@ -7527,7 +7616,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecKwargs = false;
         let condition = [];
         const argResults = [];
-        matchResults.argParams.forEach((argParam) => {
+        matchResults.argParams.forEach((argParam, argParamIndex) => {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                 skipUnknownArgCheck,
@@ -7536,6 +7625,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
+                // Add the inverse index so earlier parameters represent larger errors.
+                // This will help the heuristics in the overload error paths to pick the
+                // most likely intended overload if none of them match.
+                argumentMatchScore += 1 + (matchResults.argParams.length - argParamIndex);
             }
             if (argResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
@@ -7565,6 +7658,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (matchResults.paramSpecArgList && matchResults.paramSpecTarget) {
             if (!validateFunctionArgumentsForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext, typeCondition)) {
                 argumentErrors = true;
+                argumentMatchScore += 1;
             }
         }
         else if (type.details.paramSpec) {
@@ -7573,6 +7667,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecArgsMissing().format({ type: printType(type.details.paramSpec) }), errorNode);
                 }
                 argumentErrors = true;
+                argumentMatchScore += 1;
             }
         }
         // Calculate the return type.
@@ -7654,6 +7749,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (specializedInitSelfType) {
             specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
         }
+        matchResults.argumentMatchScore = argumentMatchScore;
         return {
             argumentErrors,
             argResults,
@@ -7698,7 +7794,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // specific use case. We may need to make this more sophisticated in
         // the future.
         if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
-            return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId);
+            const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+            // If there are no unsolved type variables, we're done. If there are
+            // unsolved type parameters, treat them as though they are rescoped
+            // to the callable.
+            if (typeVarsInReturnType.length > 0) {
+                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId, typeVarsInReturnType);
+            }
         }
         return returnType;
     }
@@ -8816,9 +8918,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Dict and MutableMapping types have invariant value types, so they
         // cannot be narrowed further. Other super-types like Mapping, Collection,
         // and Iterable use covariant value types, so they can be narrowed.
-        const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
-            (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
-                types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
+        let isValueTypeInvariant = false;
+        if ((0, types_1.isClassInstance)(inferenceContext.expectedType)) {
+            if (inferenceContext.expectedType.details.typeParameters.length >= 2) {
+                const valueTypeParam = inferenceContext.expectedType.details.typeParameters[1];
+                if (types_1.TypeVarType.getVariance(valueTypeParam) === 2 /* Invariant */) {
+                    isValueTypeInvariant = true;
+                }
+            }
+        }
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
         /* forceStrictInference */ true, isValueTypeInvariant, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
@@ -9416,7 +9524,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-        }, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
+        }, {
+            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
+        });
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -9642,13 +9752,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
-    // Converts the type parameters for a Callable type. It should
-    // have zero to two parameters. The first parameter, if present, should be
-    // either an ellipsis or a list of parameter types. The second parameter, if
-    // present, should specify the return type.
+    // Evaluates the type arguments for a Callable type. It should have zero
+    // to two arguments.The first argument, if present, should be an ellipsis,
+    // a ParamSpec, a Concatenate, or a list of positional parameter types.
+    // The second argument, if present, should specify the return type.
     function createCallableType(typeArgs, errorNode) {
-        // Create a new function that is marked as "static" so there is later
-        // no attempt to bind it as though it's an instance or class method.
         const functionType = types_1.FunctionType.createInstantiable(0 /* None */);
         types_1.TypeBase.setSpecialForm(functionType);
         functionType.details.declaredReturnType = types_1.UnknownType.create();
@@ -10342,12 +10450,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Determine if there are any generic type parameters associated
             // with this type alias.
             typeParameters = [];
-            // Skip this for a simple TypeVar (one that's not part of a union).
-            if (!(0, types_1.isTypeVar)(type) || types_1.TypeBase.isAnnotated(type)) {
-                (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
-                });
-            }
+            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParameters, (0, typeUtils_1.getTypeVarArgumentsRecursive)(subtype));
+            });
             // Don't include any synthesized type variables.
             typeParameters = typeParameters.filter((typeVar) => !typeVar.details.isSynthesized);
         }
@@ -10881,10 +10986,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // If the base class is partially evaluated, install a callback
                             // so we can fix up this class (e.g. compute the MRO) when the
                             // dependent class is completed.
-                            classTypeHooks.push({
-                                dependency: argType,
-                                callback: () => completeClassTypeDeferred(classType, node, node.name),
-                            });
+                            registerDeferredClassCompletion(node, argType);
                         }
                         if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                             if (!fileInfo.isStubFile &&
@@ -11200,8 +11302,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, dataClasses_1.applyDataClassDefaultBehaviors)(classType, dataClassBehaviors);
             (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.name, classType, initSubclassArgs, dataClassBehaviors);
         }
-        // Run any class hooks that depend on this class.
-        runClassTypeHooks(classType);
+        // Run any deferred class completions that depend on this class.
+        runDeferredClassCompletions(classType);
+        // If there are any outstanding deferred class completions registered that
+        // were not removed by the call to runDeferredClassCompletions, assume that
+        // the current class may depend on them and register for deferred completion.
+        registerDeferredClassCompletion(node, /* dependsUpon */ undefined);
         // Synthesize TypedDict methods.
         if (types_1.ClassType.isTypedDictClass(classType)) {
             (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, (0, types_1.isClass)(decoratedType) && types_1.ClassType.isFinal(decoratedType));
@@ -11434,21 +11540,47 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
         }
     }
-    // Runs any registered "callback hooks" that depend on the specified class type.
-    // This allows us to complete any work that requires dependent classes to be
-    // completed.
-    function runClassTypeHooks(type) {
-        classTypeHooks.forEach((hook) => {
-            if (types_1.ClassType.isSameGenericClass(hook.dependency, type)) {
-                hook.callback();
+    // Records the fact that the specified class requires "deferred completion" because
+    // one of its base classes has not yet been fully evaluated. If the caller passes
+    // undefined for "dependsUpon", then the class is added to all outstanding deferred
+    // completions.
+    function registerDeferredClassCompletion(classToComplete, dependsUpon) {
+        if (dependsUpon) {
+            // See if there is an existing entry for this dependency.
+            const entry = deferredClassCompletions.find((e) => types_1.ClassType.isSameGenericClass(e.dependsUpon, dependsUpon));
+            if (entry) {
+                entry.classesToComplete.push(classToComplete);
+            }
+            else {
+                deferredClassCompletions.push({ dependsUpon, classesToComplete: [classToComplete] });
+            }
+        }
+        else {
+            deferredClassCompletions.forEach((e) => {
+                e.classesToComplete.push(classToComplete);
+            });
+        }
+    }
+    // Runs any registered "deferred class completions" that depend on the specified
+    // class type. This allows us to complete any work that requires dependent classes
+    // to be completed.
+    function runDeferredClassCompletions(type) {
+        deferredClassCompletions.forEach((e) => {
+            if (types_1.ClassType.isSameGenericClass(e.dependsUpon, type)) {
+                e.classesToComplete.forEach((classNode) => {
+                    const classType = readTypeCache(classNode.name, 0 /* None */);
+                    if (classType) {
+                        completeClassTypeDeferred(classType, classNode.name);
+                    }
+                });
             }
         });
-        // Remove any hooks that depend on this type.
-        classTypeHooks = classTypeHooks.filter((hook) => !types_1.ClassType.isSameGenericClass(hook.dependency, type));
+        // Remove any completions that depend on this type.
+        deferredClassCompletions = deferredClassCompletions.filter((e) => !types_1.ClassType.isSameGenericClass(e.dependsUpon, type));
     }
     // Recomputes the MRO and effective metaclass for the class after dependent
     // classes have been fully constructed.
-    function completeClassTypeDeferred(type, node, errorNode) {
+    function completeClassTypeDeferred(type, errorNode) {
         // Recompute the MRO linearization.
         if (!(0, typeUtils_1.computeMroLinearization)(type)) {
             addError(localize_1.Localizer.Diagnostic.methodOrdering(), errorNode);
@@ -13273,10 +13405,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle "type" specially, since it needs to act like "Type"
             // in Python 3.9 and newer.
             if (types_1.ClassType.isBuiltIn(classType, 'type') && typeArgs) {
-                // PEP 484 says that type[Any] should be considered
-                // equivalent to type.
-                if (typeArgs.length === 1 && (0, types_1.isAnyOrUnknown)(typeArgs[0].type)) {
-                    return { type: classType };
+                if (typeArgs.length >= 1) {
+                    // PEP 484 says that type[Any] should be considered
+                    // equivalent to type.
+                    if ((0, types_1.isAnyOrUnknown)(typeArgs[0].type)) {
+                        return { type: classType };
+                    }
+                    // Treat type[function] as illegal.
+                    if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloadedFunction)(typeArgs[0].type)) {
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAnnotationWithCallable(), typeArgs[0].node);
+                        return { type: types_1.UnknownType.create() };
+                    }
                 }
                 const typeClass = getTypingType(errorNode, 'Type');
                 if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
@@ -13528,13 +13667,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // used in cases where the argument is expected to be a type
     // and therefore follows the normal rules of types (e.g. they
     // can be forward-declared in stubs, etc.).
-    function getTypeOfArgumentExpectingType(arg) {
+    function getTypeOfArgumentExpectingType(arg, options) {
         if (arg.typeResult) {
             return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
-        return getTypeOfExpressionExpectingType(arg.valueExpression);
+        return getTypeOfExpressionExpectingType(arg.valueExpression, options);
     }
     function getTypeOfExpressionExpectingType(node, options) {
         let flags = 128 /* ExpectingInstantiableType */ |
@@ -13565,6 +13704,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
             flags |= 32 /* DisallowParamSpec */;
         }
+        if (options === null || options === void 0 ? void 0 : options.enforceTypeAnnotationRules) {
+            flags |= 256 /* ExpectingTypeAnnotation */;
+        }
         return getTypeOfExpression(node, flags);
     }
     function getBuiltInType(node, name) {
@@ -13695,11 +13837,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types, under the assumption that we're performing speculative evaluations.
     // If speculativeNode is undefined, speculative mode is not used. This is
     // useful in cases where we conditionally want to use speculative mode.
-    function useSpeculativeMode(speculativeNode, callback, dependentType) {
+    function useSpeculativeMode(speculativeNode, callback, options) {
         if (!speculativeNode) {
             return callback();
         }
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, dependentType);
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, options);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -15156,6 +15298,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         });
+        if (!isAssignable) {
+            return false;
+        }
         // Now handle generic base classes.
         destType.details.baseClasses.forEach((baseClass) => {
             if ((0, types_1.isInstantiableClass)(baseClass) &&
@@ -15401,63 +15546,50 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             srcTypeArgs = srcType.typeArguments;
         }
         let isCompatible = true;
-        if (srcTypeArgs) {
-            for (let srcArgIndex = 0; srcArgIndex < srcTypeArgs.length; srcArgIndex++) {
-                const srcTypeArg = srcTypeArgs[srcArgIndex];
-                // In most cases, the number of type args should match the number
-                // of type arguments, but there are a few special cases where this
-                // isn't true (e.g. assigning a Tuple[X, Y, Z] to a tuple[W]).
-                const destArgIndex = srcArgIndex >= destTypeArgs.length ? destTypeArgs.length - 1 : srcArgIndex;
-                const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
-                const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
-                const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
-                if (!destTypeParam || types_1.TypeVarType.getVariance(destTypeParam) === 3 /* Covariant */) {
-                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
-                        if (diag) {
-                            if (destTypeParam) {
-                                const childDiag = diag.createAddendum();
-                                childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant().format({
-                                    name: types_1.TypeVarType.getReadableName(destTypeParam),
-                                }));
-                                childDiag.addAddendum(assignmentDiag);
-                            }
-                            else {
-                                diag.addAddendum(assignmentDiag);
-                            }
-                        }
-                        isCompatible = false;
-                    }
-                }
-                else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
-                    if (!assignType(srcTypeArg, destTypeArg, assignmentDiag, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
-                        if (diag) {
+        srcTypeArgs === null || srcTypeArgs === void 0 ? void 0 : srcTypeArgs.forEach((srcTypeArg, srcArgIndex) => {
+            // In most cases, the number of type args should match the number
+            // of type arguments, but there are a few special cases where this
+            // isn't true (e.g. assigning a Tuple[X, Y, Z] to a tuple[W]).
+            const destArgIndex = srcArgIndex >= destTypeArgs.length ? destTypeArgs.length - 1 : srcArgIndex;
+            const destTypeArg = destArgIndex >= 0 ? destTypeArgs[destArgIndex] : types_1.UnknownType.create();
+            const destTypeParam = destArgIndex < destTypeParams.length ? destTypeParams[destArgIndex] : undefined;
+            const assignmentDiag = new diagnostic_1.DiagnosticAddendum();
+            const variance = destTypeParam ? types_1.TypeVarType.getVariance(destTypeParam) : 3 /* Covariant */;
+            let effectiveFlags;
+            let errorSource;
+            if (variance === 3 /* Covariant */) {
+                effectiveFlags = flags | 128 /* RetainLiteralsForTypeVar */;
+                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsCovariant;
+            }
+            else if (variance === 4 /* Contravariant */) {
+                effectiveFlags =
+                    (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */;
+                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant;
+            }
+            else {
+                effectiveFlags = flags | 1 /* EnforceInvariance */ | 128 /* RetainLiteralsForTypeVar */;
+                errorSource = localize_1.Localizer.DiagnosticAddendum.typeVarIsInvariant;
+            }
+            if (!assignType(variance === 4 /* Contravariant */ ? srcTypeArg : destTypeArg, variance === 4 /* Contravariant */ ? destTypeArg : srcTypeArg, assignmentDiag, variance === 4 /* Contravariant */ ? srcTypeVarContext : destTypeVarContext, variance === 4 /* Contravariant */ ? destTypeVarContext : srcTypeVarContext, effectiveFlags, recursionCount)) {
+                // Don't report errors with type variables in "pseudo-random"
+                // classes since these type variables are not real.
+                if (!types_1.ClassType.isPseudoGenericClass(destType)) {
+                    if (diag) {
+                        if (destTypeParam) {
                             const childDiag = diag.createAddendum();
-                            childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsContravariant().format({
+                            childDiag.addMessage(errorSource().format({
                                 name: types_1.TypeVarType.getReadableName(destTypeParam),
+                                ...printSrcDestTypes(srcTypeArg, destTypeArg),
                             }));
-                            childDiag.addAddendum(assignmentDiag);
                         }
-                        isCompatible = false;
-                    }
-                }
-                else {
-                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 /* EnforceInvariance */ | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
-                        // Don't report errors with type variables in "pseudo-random"
-                        // classes since these type variables are not real.
-                        if (!types_1.ClassType.isPseudoGenericClass(destType)) {
-                            if (diag) {
-                                const childDiag = diag.createAddendum();
-                                childDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeVarIsInvariant().format({
-                                    name: types_1.TypeVarType.getReadableName(destTypeParam),
-                                }));
-                                childDiag.addAddendum(assignmentDiag);
-                            }
-                            isCompatible = false;
+                        else {
+                            diag.addAddendum(assignmentDiag);
                         }
                     }
+                    isCompatible = false;
                 }
             }
-        }
+        });
         return isCompatible;
     }
     // Determines if the source type can be assigned to the dest type.
@@ -15647,8 +15779,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     destType.details.parameters.length <= 2) {
                     return true;
                 }
-                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
-                return false;
+                if (!(0, types_1.isUnion)(destType)) {
+                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
+                    return false;
+                }
             }
         }
         if ((0, types_1.isAnyOrUnknown)(destType)) {
@@ -15678,25 +15812,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return true;
         }
         if ((0, types_1.isUnion)(destType)) {
+            // If both the source and dest are unions, use assignFromUnionType which has
+            // special-case logic to handle this case.
             if ((0, types_1.isUnion)(srcType)) {
-                if (assignFromUnionType(destType, srcType, 
-                /* diag */ undefined, destTypeVarContext, srcTypeVarContext, originalFlags, recursionCount)) {
-                    return true;
-                }
+                return assignFromUnionType(destType, srcType, 
+                /* diag */ undefined, destTypeVarContext, srcTypeVarContext, originalFlags, recursionCount);
             }
-            else {
-                const clonedDestTypeVarContext = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
-                const clonedSrcTypeVarContext = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
-                if (assignToUnionType(destType, srcType, 
-                /* diag */ undefined, clonedDestTypeVarContext, clonedSrcTypeVarContext, originalFlags, recursionCount)) {
-                    if (destTypeVarContext && clonedDestTypeVarContext) {
-                        destTypeVarContext.copyFromClone(clonedDestTypeVarContext);
-                    }
-                    if (srcTypeVarContext && clonedSrcTypeVarContext) {
-                        srcTypeVarContext.copyFromClone(clonedSrcTypeVarContext);
-                    }
-                    return true;
+            const clonedDestTypeVarContext = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
+            const clonedSrcTypeVarContext = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
+            if (assignToUnionType(destType, srcType, 
+            /* diag */ undefined, clonedDestTypeVarContext, clonedSrcTypeVarContext, originalFlags, recursionCount)) {
+                if (destTypeVarContext && clonedDestTypeVarContext) {
+                    destTypeVarContext.copyFromClone(clonedDestTypeVarContext);
+                }
+                if (srcTypeVarContext && clonedSrcTypeVarContext) {
+                    srcTypeVarContext.copyFromClone(clonedSrcTypeVarContext);
                 }
+                return true;
             }
         }
         const expandedSrcType = makeTopLevelTypeVarsConcrete(srcType);
@@ -16047,6 +16179,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // whose primary type matches.
             remainingSrcSubtypes.forEach((srcSubtype) => {
                 const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => {
+                    if ((0, types_1.isTypeSame)(destSubtype, srcSubtype)) {
+                        return true;
+                    }
                     if ((0, types_1.isClass)(srcSubtype) &&
                         (0, types_1.isClass)(destSubtype) &&
                         types_1.TypeBase.isInstance(srcSubtype) === types_1.TypeBase.isInstance(destSubtype) &&
@@ -16071,6 +16206,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If there is are remaining dest subtypes and they're all type variables,
             // attempt to assign the remaining source subtypes to them.
             if (canUseFastPath && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
+                if ((flags & 1 /* EnforceInvariance */) !== 0) {
+                    // If we have no src subtypes remaining but not all dest types have been subsumed
+                    // by other dest types, then the types are not compatible if we're enforcing invariance.
+                    if (remainingSrcSubtypes.length === 0) {
+                        return remainingDestSubtypes.every((destSubtype) => isTypeSubsumedByOtherType(destSubtype, destType.subtypes, 
+                        /* allowAnyToSubsume */ true, recursionCount));
+                    }
+                }
                 const isReversed = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
                 const effectiveDestSubtypes = isReversed ? remainingSrcSubtypes : remainingDestSubtypes;
                 if (effectiveDestSubtypes.length === 0 || effectiveDestSubtypes.some((t) => !(0, types_1.isTypeVar)(t))) {
@@ -16122,21 +16265,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (!assignType(destType, subtype, 
             /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
-                let isSubtypeSubsumed = false;
-                srcType.subtypes.forEach((innerSubtype) => {
-                    if (!isSubtypeSubsumed &&
-                        !(0, types_1.isTypeSame)(innerSubtype, subtype) &&
-                        !(0, types_1.isAnyOrUnknown)(innerSubtype) &&
-                        isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
-                        isSubtypeSubsumed = true;
-                    }
-                });
+                const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType.subtypes, 
+                /* allowAnyToSubsume */ false, recursionCount);
                 // Try again with a concrete version of the subtype.
                 if (!isSubtypeSubsumed &&
-                    !assignType(destType, concreteSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    !assignType(destType, subtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     isIncompatible = true;
                 }
             }
@@ -16147,6 +16282,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
+    // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) one
+    // of the other types in a list.
+    function isTypeSubsumedByOtherType(type, otherTypes, allowAnyToSubsume, recursionCount = 0) {
+        const concreteType = makeTopLevelTypeVarsConcrete(type);
+        for (const otherType of otherTypes) {
+            if ((0, types_1.isTypeSame)(otherType, type)) {
+                continue;
+            }
+            if ((0, types_1.isAnyOrUnknown)(otherType)) {
+                if (allowAnyToSubsume) {
+                    return true;
+                }
+            }
+            else if (isProperSubtype(otherType, concreteType, recursionCount)) {
+                return true;
+            }
+        }
+        return false;
+    }
     // Determines whether the srcType is a subtype of destType but the converse
     // is not true. It's important that we check both directions to avoid
     // matches for types like `tuple[Any]` and `tuple[int]` from being considered