@zzzen/pyright-internal 1.2.0-dev.20240505 → 1.2.0-dev.20240519

package/dist/analyzer/typeEvaluator.js

@@ -3118,6 +3118,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (a function, lambda, or comprehension).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
+        // This function applies only to captured variables, not those that
+        // are accessed via an explicit nonlocal or global binding.
+        if (symbolWithScope.usesGlobalBinding || symbolWithScope.usesNonlocalBinding) {
+            return undefined;
+        }
         // This function applies only to variables, parameters, and imports, not to other
         // types of symbols.
         const decls = symbolWithScope.symbol.getDeclarations();
@@ -3225,14 +3230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (memberName === 'args' || memberName === 'kwargs') {
                                 const outerFunctionScope = ParseTreeUtils.getEnclosingClassOrFunction(enclosingScope);
                                 if ((outerFunctionScope === null || outerFunctionScope === void 0 ? void 0 : outerFunctionScope.nodeType) === 28 /* ParseNodeType.Function */) {
-                                    if (scopedTypeVarInfo.isRescoped) {
-                                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecScopedToReturnType().format({
-                                            name: type.details.name,
-                                        }), node);
-                                    }
-                                    else {
-                                        enclosingScope = outerFunctionScope;
-                                    }
+                                    enclosingScope = outerFunctionScope;
                                 }
                                 else if (!scopedTypeVarInfo.type.scopeId) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.paramSpecNotUsedByOuterScope().format({
@@ -3267,17 +3265,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if ((flags & 4096 /* EvaluatorFlags.AllowTypeVarsWithoutScopeId */) === 0) {
                 if ((type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized) {
-                    let message;
-                    if (scopedTypeVarInfo.isRescoped) {
-                        message = (0, types_1.isParamSpec)(type)
-                            ? localize_1.LocMessage.paramSpecScopedToReturnType()
-                            : localize_1.LocMessage.typeVarScopedToReturnType();
-                    }
-                    else {
-                        message = (0, types_1.isParamSpec)(type)
-                            ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
-                            : localize_1.LocMessage.typeVarNotUsedByOuterScope();
-                    }
+                    const message = (0, types_1.isParamSpec)(type)
+                        ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
+                        : localize_1.LocMessage.typeVarNotUsedByOuterScope();
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message.format({ name: type.details.name }), node);
                 }
             }
@@ -3352,7 +3342,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Walks up the parse tree to find a function, class, or type alias
     // declaration that provides the context for a type variable.
     function findScopedTypeVar(node, type) {
-        var _a;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
@@ -3376,12 +3365,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (functionType) {
                     const functionDetails = functionType.details;
                     typeParametersForScope = functionDetails.typeParameters;
-                    // Was this type parameter "rescoped" to a callable found within the
-                    // return type annotation? If so, it is not available for use within
-                    // the function body.
-                    if ((_a = functionDetails.rescopedTypeParameters) === null || _a === void 0 ? void 0 : _a.some((tp) => tp.details.name === type.details.name)) {
-                        return { type, isRescoped: true, foundInterveningClass: false };
-                    }
                 }
                 scopeUsesTypeParameterSyntax = !!curNode.typeParameters;
             }
@@ -3395,7 +3378,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type = types_1.TypeVarType.cloneForScopeId(type, match.scopeId, match.scopeName, match.scopeType);
                     return {
                         type,
-                        isRescoped: false,
                         foundInterveningClass: nestedClassCount > 1 && !scopeUsesTypeParameterSyntax,
                     };
                 }
@@ -3436,13 +3418,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (allowedTypeParams) {
                             if (!allowedTypeParams.some((param) => param.details.name === type.details.name)) {
                                 // Return the original type.
-                                return { type, isRescoped: false, foundInterveningClass: false };
+                                return { type, foundInterveningClass: false };
                             }
                         }
                     }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.details.recursiveTypeAliasScopeId, leftType.details.recursiveTypeAliasName, 2 /* TypeVarScopeType.TypeAlias */),
-                        isRescoped: false,
                         foundInterveningClass: false,
                     };
                 }
@@ -3450,7 +3431,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             curNode = curNode.parent;
         }
         // Return the original type.
-        return { type, isRescoped: false, foundInterveningClass: false };
+        return { type, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
         var _a;
@@ -3542,7 +3523,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a;
+        var _a, _b;
         let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.memberName.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3627,8 +3608,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 6 /* TypeCategory.Class */: {
                 let typeResult;
-                if (usage.method === 'get') {
-                    typeResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
+                const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
+                if (enumMemberResult) {
+                    if (usage.method === 'get') {
+                        typeResult = enumMemberResult;
+                    }
+                    else {
+                        // Is this an attempt to delete or overwrite an enum member?
+                        if ((0, types_1.isClassInstance)(enumMemberResult.type) &&
+                            types_1.ClassType.isSameGenericClass(enumMemberResult.type, baseType) &&
+                            enumMemberResult.type.literalValue !== undefined) {
+                            const diagMessage = usage.method === 'set' ? localize_1.LocMessage.enumMemberSet() : localize_1.LocMessage.enumMemberDelete();
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, diagMessage.format({ name: memberName }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
+                        }
+                    }
                 }
                 if (!typeResult) {
                     typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
@@ -3814,7 +3807,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const rule = isFunctionRule
                     ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
                     : diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue;
-                addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : node.memberName);
+                addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.memberName, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node.memberName);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -5274,19 +5267,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const unboundedIndex = tupleTypeArgs.findIndex((typeArg) => typeArg.isUnbounded || (0, types_1.isVariadicTypeVar)(typeArg.type));
             if (value < 0) {
                 value = tupleTypeArgs.length + value;
-                if (value < 0) {
+                if (unboundedIndex >= 0 && value <= unboundedIndex) {
                     return undefined;
                 }
-                else if (unboundedIndex >= 0 && value <= unboundedIndex) {
-                    return undefined;
+                else if (value < 0) {
+                    return 0;
                 }
             }
             else {
-                if (value > tupleTypeArgs.length) {
+                if (unboundedIndex >= 0 && value > unboundedIndex) {
                     return undefined;
                 }
-                else if (unboundedIndex >= 0 && value > unboundedIndex) {
-                    return undefined;
+                else if (value > tupleTypeArgs.length) {
+                    return tupleTypeArgs.length;
                 }
             }
         }
@@ -5889,7 +5882,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.arguments.length > 0) {
             targetClassType = getTypeOfExpression(node.arguments[0].valueExpression).type;
             const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
-            if (!(0, types_1.isAnyOrUnknown)(concreteTargetClassType) && !(0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+            if (!(0, types_1.isAnyOrUnknown)(concreteTargetClassType) &&
+                !(0, types_1.isInstantiableClass)(concreteTargetClassType) &&
+                !(0, typeUtils_1.isMetaclassInstance)(concreteTargetClassType)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.superCallFirstArg().format({ type: printType(targetClassType) }), node.arguments[0].valueExpression);
             }
         }
@@ -6809,19 +6804,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (expandedCallType.details.name === 'type' && argList.length === 1) {
                     const argType = getTypeOfArgument(argList[0]).type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
-                        var _a;
-                        if ((0, types_1.isInstantiableClass)(subtype)) {
-                            return (_a = subtype.details.effectiveMetaclass) !== null && _a !== void 0 ? _a : types_1.AnyType.create();
+                        if ((0, types_1.isInstantiableClass)(subtype) && subtype.details.effectiveMetaclass) {
+                            return subtype.details.effectiveMetaclass;
                         }
-                        if ((0, types_1.isClassInstance)(subtype) ||
-                            ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstance(subtype)) ||
-                            (0, typeUtils_1.isNoneInstance)(subtype)) {
-                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
+                        if ((0, types_1.isNever)(subtype)) {
+                            return subtype;
                         }
-                        if ((0, types_1.isFunction)(subtype) && types_1.TypeBase.isInstance(subtype)) {
-                            return types_1.FunctionType.cloneAsInstantiable(subtype);
+                        if (types_1.TypeBase.isInstance(subtype)) {
+                            if ((0, types_1.isClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
+                                return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
+                            }
+                            if ((0, types_1.isFunction)(subtype)) {
+                                return types_1.FunctionType.cloneAsInstantiable(subtype);
+                            }
                         }
-                        return types_1.AnyType.create();
+                        return types_1.ClassType.cloneForSpecialization(types_1.ClassType.cloneAsInstance(expandedCallType), [types_1.UnknownType.create()], 
+                        /* isTypeArgumentExplicit */ true);
                     });
                     return { returnType };
                 }
@@ -8177,7 +8175,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // call to a generic function or if this isn't a callable
         // return with type parameters that are rescoped from the original
         // function to the returned callable.
-        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope)) && !type.details.rescopedTypeParameters;
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
@@ -8456,7 +8454,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
                         32 /* EvaluatorFlags.DisallowParamSpec */ |
                         64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16 /* EvaluatorFlags.DisallowFinal */
+                        16 /* EvaluatorFlags.DisallowFinal */ |
+                        2 /* EvaluatorFlags.DoNotSpecialize */
                     : 2 /* EvaluatorFlags.DoNotSpecialize */ | 16 /* EvaluatorFlags.DisallowFinal */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
@@ -8937,9 +8936,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return paramSpec;
     }
     function getParamSpecDefaultType(node, isPep695Syntax) {
-        const functionType = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */ | 65536 /* FunctionTypeFlags.ParamSpecValue */);
+        const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */);
         if (node.nodeType === 18 /* ParseNodeType.Ellipsis */) {
             types_1.FunctionType.addDefaultParameters(functionType);
+            functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
             return functionType;
         }
         if (node.nodeType === 31 /* ParseNodeType.List */) {
@@ -10591,7 +10591,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             literalTypes.push(type);
         }
-        return (0, types_1.combineTypes)(literalTypes);
+        let result = (0, types_1.combineTypes)(literalTypes);
+        if ((0, types_1.isUnion)(result) && unionClassType && (0, types_1.isInstantiableClass)(unionClassType)) {
+            result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionClassType));
+        }
+        return result;
     }
     // Creates a ClassVar type.
     function createClassVarType(classType, errorNode, typeArgs, flags) {
@@ -11301,7 +11305,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function evaluateTypesForAssignmentStatement(node) {
-        var _a, _b;
+        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
@@ -11402,20 +11406,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 // If this is an enum, transform the type as required.
                 rightHandType = srcType;
-                let targetName;
-                if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    targetName = node.leftExpression;
-                }
-                else if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */ &&
-                    node.leftExpression.valueExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    targetName = node.leftExpression.valueExpression;
-                }
-                if (targetName) {
-                    rightHandType =
-                        (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, targetName, () => {
-                            return { assignedType: rightHandType };
-                        })) !== null && _a !== void 0 ? _a : rightHandType;
-                }
                 if (typeAliasNameNode) {
                     // If this was a speculative type alias, it becomes a real type alias
                     // only if the evaluated type is an instantiable type.
@@ -11436,7 +11426,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         typeAliasTypeVar.details.boundType = rightHandType;
                         // Record the type parameters within the recursive type alias so it
                         // can be specialized.
-                        typeAliasTypeVar.details.recursiveTypeParameters = (_b = rightHandType.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeParameters;
+                        typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
                     }
                 }
             }
@@ -12378,9 +12368,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         const errorNode = argList.length > 0 ? (_b = (_a = argList[0].node) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : node.name : node.name;
         let newMethodMember;
+        // See if the class has a metaclass that overrides `__new__`. If so, we
+        // will validate the signature of the `__new__` method.
         if (classType.details.effectiveMetaclass && (0, types_1.isClass)(classType.details.effectiveMetaclass)) {
-            // See if the metaclass has a `__new__` method that accepts keyword parameters.
-            newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 8 /* MemberAccessFlags.SkipTypeBaseClass */);
+            // If the metaclass is 'type' or 'ABCMeta', we'll assume it will call through to
+            // __init_subclass__, so we'll skip the `__new__` method check. We need to exclude
+            // TypedDict classes here because _TypedDict uses ABCMeta as its metaclass, but its
+            // typeshed definition doesn't override __init_subclass__.
+            const metaclassCallsInitSubclass = types_1.ClassType.isBuiltIn(classType.details.effectiveMetaclass, ['ABCMeta', 'type']) &&
+                !types_1.ClassType.isTypedDictClass(classType);
+            if (!metaclassCallsInitSubclass) {
+                // See if the metaclass has a `__new__` method that accepts keyword parameters.
+                newMethodMember = (0, typeUtils_1.lookUpClassMember)(classType.details.effectiveMetaclass, '__new__', 8 /* MemberAccessFlags.SkipTypeBaseClass */);
+            }
         }
         if (newMethodMember) {
             const newMethodType = getTypeOfMember(newMethodMember);
@@ -12474,7 +12474,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function getTypeOfFunction(node) {
-        var _a;
         initializedBasicTypes(node);
         // Is this predecorated function type cached?
         let functionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
@@ -12522,11 +12521,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 decoratedType = newDecoratedType;
             }
         }
-        // In case this is an enum class and a method wrapped in an enum.member.
-        decoratedType =
-            (_a = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, node, node.name, () => {
-                return { assignedType: decoratedType };
-            })) !== null && _a !== void 0 ? _a : decoratedType;
         // See if there are any overloads provided by previous function declarations.
         if ((0, types_1.isFunction)(decoratedType)) {
             decoratedType.details.deprecatedMessage = functionType.details.deprecatedMessage;
@@ -12824,6 +12818,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
             }
         }
+        // If the function contains an *args and a **kwargs parameter and both
+        // are annotated as Any or are unannotated, make it exempt from
+        // args/kwargs compatibility checks.
+        const variadicsWithAnyType = functionType.details.parameters.filter((param) => param.category !== 0 /* ParameterCategory.Simple */ && param.name && (0, types_1.isAnyOrUnknown)(param.type));
+        if (variadicsWithAnyType.length >= 2) {
+            functionType.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
+        }
         // If there was a defined return type, analyze that first so when we
         // walk the contents of the function, return statements can be
         // validated against this type.
@@ -12853,7 +12854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Accumulate any type parameters used in the return type.
         if (functionType.details.declaredReturnType && returnTypeAnnotationNode) {
-            rescopeTypeVarsForCallableReturnType(functionType.details.declaredReturnType, functionType, typeParametersSeen);
+            (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, (0, typeUtils_1.getTypeVarArgumentsRecursive)(functionType.details.declaredReturnType), functionType.details.typeVarScopeId);
         }
         // If the return type is explicitly annotated as a generator, mark the
         // function as a generator even though it may not contain a "yield" statement.
@@ -12894,34 +12895,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    // If the declared return type of a function contains type variables that
-    // are found nowhere else in the signature and are contained within a
-    // Callable, these type variables are "rescoped" from the function to
-    // the Callable.
-    function rescopeTypeVarsForCallableReturnType(returnType, functionType, typeParametersSeen) {
-        const typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType).filter((t) => t.scopeId === functionType.details.typeVarScopeId);
-        const rescopedTypeVars = [];
-        typeVarsInReturnType.forEach((typeVar) => {
-            if (types_1.TypeBase.isInstantiable(typeVar)) {
-                typeVar = types_1.TypeVarType.cloneAsInstance(typeVar);
-            }
-            // If this type variable was already seen in one or more input parameters,
-            // don't attempt to rescope it.
-            if (typeParametersSeen.some((tp) => (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(tp), typeVar))) {
-                return;
-            }
-            // Is this type variable seen outside of a single callable?
-            if ((0, typeUtils_1.isTypeVarLimitedToCallable)(returnType, typeVar)) {
-                rescopedTypeVars.push(typeVar);
-            }
-        });
-        (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParametersSeen, typeVarsInReturnType);
-        // Note that the type parameters have been rescoped so they are not
-        // considered valid for the body of this function.
-        if (rescopedTypeVars.length > 0) {
-            functionType.details.rescopedTypeParameters = rescopedTypeVars;
-        }
-    }
     function adjustParameterAnnotatedType(param, type) {
         var _a;
         // PEP 484 indicates that if a parameter has a default value of 'None'
@@ -15039,7 +15012,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return declarations;
     }
     function getTypeForDeclaration(declaration) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         switch (declaration.type) {
             case 0 /* DeclarationType.Intrinsic */: {
                 if (declaration.intrinsicType === 'Any') {
@@ -15146,16 +15119,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         });
                     }
                     if (declaredType) {
-                        // Apply enum transform if appropriate.
-                        if (declaration.node.nodeType === 38 /* ParseNodeType.Name */) {
-                            const variableNode = (_c = ParseTreeUtils.getParentNodeOfType(declaration.node, 3 /* ParseNodeType.Assignment */)) !== null && _c !== void 0 ? _c : ParseTreeUtils.getParentNodeOfType(declaration.node, 54 /* ParseNodeType.TypeAnnotation */);
-                            if (variableNode) {
-                                declaredType =
-                                    (_d = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, declaration.node, () => {
-                                        return { declaredType };
-                                    })) !== null && _d !== void 0 ? _d : declaredType;
-                            }
-                        }
                         if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
                             return { type: undefined, isTypeAlias: true };
                         }
@@ -15295,7 +15258,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeVar;
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
             allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
         });
@@ -15418,25 +15381,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let inferredType = (_c = evaluateTypeForSubnode(resolvedDecl.node, () => {
                 evaluateTypesForStatement(typeSource);
             })) === null || _c === void 0 ? void 0 : _c.type;
-            if (inferredType && resolvedDecl.node.nodeType === 38 /* ParseNodeType.Name */) {
-                const variableNode = (_d = ParseTreeUtils.getParentNodeOfType(resolvedDecl.node, 3 /* ParseNodeType.Assignment */)) !== null && _d !== void 0 ? _d : ParseTreeUtils.getParentNodeOfType(resolvedDecl.node, 54 /* ParseNodeType.TypeAnnotation */);
-                if (variableNode) {
-                    // See if this is an enum member. If so, we need to handle it as a special case.
-                    const enumMemberType = (0, enums_1.transformTypeForPossibleEnumClass)(evaluatorInterface, variableNode, resolvedDecl.node, () => {
-                        var _a, _b;
-                        (0, debug_1.assert)(resolvedDecl.inferredTypeSource !== undefined);
-                        const inferredTypeSource = resolvedDecl.inferredTypeSource;
-                        return {
-                            assignedType: (_b = (_a = evaluateTypeForSubnode(inferredTypeSource, () => {
-                                evaluateTypesForStatement(inferredTypeSource);
-                            })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create(),
-                        };
-                    });
-                    if (enumMemberType) {
-                        inferredType = enumMemberType;
-                    }
-                }
-            }
             if (inferredType && isTypeAlias && resolvedDecl.typeAliasName) {
                 // If this was a speculative type alias, it becomes a real type alias only
                 // in the event that its inferred type is instantiable or explicitly Any
@@ -16782,7 +16726,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // in the dest type is not in the type map already, it is assigned a type
     // and added to the map.
     function assignType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
-        var _a, _b;
+        var _a, _b, _c;
         // Handle the case where the dest and src types are the same object.
         // We can normally shortcut this and say that they are compatible,
         // but if the type includes TypeVars, we need to go through
@@ -17111,6 +17055,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return false;
                     }
                 }
+                if (types_1.ClassType.isBuiltIn(destType, 'type') && ((_c = srcType.instantiableNestingLevel) !== null && _c !== void 0 ? _c : 0) > 0) {
+                    return true;
+                }
                 if (!isSpecialFormClass(expandedSrcType, flags) &&
                     assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
                     /* reportErrorsUsingObjType */ false)) {
@@ -17841,21 +17788,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, destTypeVarContext, flags, recursionCount)) {
-            // There are cases involving lambdas where the parameter types are type
-            // variables and match exactly but fail the assignment check because the
-            // TypeVars are out of scope. This happens because parameter types assigned
-            // to lambdas during bidirectional inference do not match the TypeVar scope
-            // of the lambda itself.
-            if (!(0, types_1.isTypeSame)(destType, srcType)) {
-                if (diag && paramIndex !== undefined) {
-                    diag.addMessage(localize_1.LocAddendum.paramAssignment().format({
-                        index: paramIndex + 1,
-                        sourceType: printType(destType),
-                        destType: printType(srcType),
-                    }));
-                }
-                return false;
+            if (diag && paramIndex !== undefined) {
+                diag.addMessage(localize_1.LocAddendum.paramAssignment().format({
+                    index: paramIndex + 1,
+                    sourceType: printType(destType),
+                    destType: printType(srcType),
+                }));
             }
+            return false;
         }
         return true;
     }
@@ -17883,6 +17823,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (srcLastToPackIndex < 0) {
             srcLastToPackIndex = srcDetails.params.length;
         }
+        // If both the source and dest have an *args parameter but the dest's is
+        // in a later position, then we can't assign the source's *args to the dest.
+        // Don't make any adjustment in this case.
+        if (srcDetails.argsIndex !== undefined && destDetails.argsIndex > srcDetails.argsIndex) {
+            return;
+        }
         const destFirstNonPositional = (_a = destDetails.firstKeywordOnlyIndex) !== null && _a !== void 0 ? _a : destDetails.params.length;
         const suffixLength = destFirstNonPositional - destDetails.argsIndex - 1;
         const srcPositionalsToPack = srcDetails.params.slice(destDetails.argsIndex, srcLastToPackIndex - suffixLength);
@@ -17936,7 +17882,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function assignFunction(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) === 0;
         const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
@@ -18010,7 +17956,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 destParam.param.hasDeclaredType) {
                 continue;
             }
-            if (!assignFunctionParameter(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            if ((0, types_1.isUnpacked)(srcParamType)) {
+                canAssign = false;
+            }
+            else if (!assignFunctionParameter(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                 // Handle the special case where the source parameter is a synthesized
                 // TypeVar for "self" or "cls".
                 if ((flags & 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */) === 0 ||
@@ -18019,6 +17968,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     canAssign = false;
                 }
             }
+            else if (destParam.source !== parameterUtils_1.ParameterSource.PositionOnly &&
+                srcParam.source === parameterUtils_1.ParameterSource.PositionOnly &&
+                srcParamDetails.kwargsIndex === undefined &&
+                !srcParamDetails.params.some((p) => p.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+                    p.param.category === 0 /* ParameterCategory.Simple */ &&
+                    p.param.name === destParam.param.name)) {
+                diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
+                    name: (_e = destParam.param.name) !== null && _e !== void 0 ? _e : '',
+                }));
+                canAssign = false;
+            }
         }
         if (!types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(destType) &&
             destParamDetails.firstPositionOrKeywordIndex < srcParamDetails.positionOnlyParamCount &&
@@ -18082,7 +18042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (destParamDetails.params[paramIndex].source !== parameterUtils_1.ParameterSource.PositionOnly &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                                name: (_e = destParamDetails.params[paramIndex].param.name) !== null && _e !== void 0 ? _e : '',
+                                name: (_f = destParamDetails.params[paramIndex].param.name) !== null && _f !== void 0 ? _f : '',
                             }));
                             canAssign = false;
                         }
@@ -18130,7 +18090,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destParamDetails.argsIndex !== undefined &&
             !destParamDetails.hasUnpackedVariadicTypeVar) {
             diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.argsParamMissing().format({
-                paramName: (_f = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _f !== void 0 ? _f : '',
+                paramName: (_g = destParamDetails.params[destParamDetails.argsIndex].param.name) !== null && _g !== void 0 ? _g : '',
             }));
             canAssign = false;
         }
@@ -18243,7 +18203,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the source and the dest are using the same ParamSpec, any additional
         // concatenated parameters must match.
         if (targetIncludesParamSpec &&
-            ((_g = srcType.details.paramSpec) === null || _g === void 0 ? void 0 : _g.nameWithScope) === ((_h = destType.details.paramSpec) === null || _h === void 0 ? void 0 : _h.nameWithScope)) {
+            ((_h = srcType.details.paramSpec) === null || _h === void 0 ? void 0 : _h.nameWithScope) === ((_j = destType.details.paramSpec) === null || _j === void 0 ? void 0 : _j.nameWithScope)) {
             if (srcParamDetails.params.length !== destParamDetails.params.length) {
                 canAssign = false;
             }