@zzzen/pyright-internal 1.2.0-dev.20241006 → 1.2.0-dev.20241020

package/dist/analyzer/typeEvaluator.js

@@ -158,6 +158,11 @@ const maxInferFunctionReturnRecursionCount = 12;
 // it can increase the chance of false negatives for such recursive
 // type aliases.
 const maxRecursiveTypeAliasRecursionCount = 10;
+// Normally a symbol can have only one type declaration, but there are
+// cases where multiple are possible (e.g. a property with a setter
+// and a deleter). In extreme cases, we need to limit the number of
+// type declarations we consider to avoid excessive computation.
+const maxTypedDeclsPerSymbol = 16;
 // This switch enables a special debug mode that attempts to catch
 // bugs due to inconsistent evaluation flags used when reading types
 // from the type cache.
@@ -892,7 +897,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
-        else if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
+        else if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
             (0, types_1.isInstantiableClass)(iterType) &&
             types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
             typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
@@ -999,7 +1004,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let typeResult;
         // In most cases, annotations within a string are not parsed by the interpreter.
         // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
-        if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
+        if ((flags & 16777216 /* EvalFlags.ParsesStringLiteral */) === 0) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
         updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
@@ -1109,7 +1114,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
-            var _a;
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.priv.literalValue !== undefined) {
                     subtype = types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
@@ -1118,9 +1122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Handle "LiteralString" specially.
                     if (strClass && (0, types_1.isInstantiableClass)(strClass)) {
                         let strInstance = types_1.ClassType.cloneAsInstance(strClass);
-                        if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) {
-                            strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
-                        }
+                        strInstance = types_1.TypeBase.cloneForCondition(strInstance, (0, typeUtils_1.getTypeCondition)(subtype));
                         return strInstance;
                     }
                 }
@@ -1554,10 +1556,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function getBoundMagicMethod(classType, memberName, selfType, diag, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
         const boundMethodResult = getTypeOfBoundMember(
         /* errorNode */ undefined, classType, memberName, 
         /* usage */ undefined, diag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, selfType, recursionCount);
@@ -1568,6 +1566,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
+            if (recursionCount > types_1.maxTypeRecursionCount) {
+                return undefined;
+            }
+            recursionCount++;
             return getBoundMagicMethod(boundMethodResult.type, '__call__', selfType !== null && selfType !== void 0 ? selfType : types_1.ClassType.cloneAsInstance(classType), diag, recursionCount);
         }
         if ((0, types_1.isAnyOrUnknown)(boundMethodResult.type)) {
@@ -2308,7 +2310,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
         if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            if (!assignType(declaredType, typeResult.type, diagAddendum)) {
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(nameNode);
+            const boundDeclaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveScopeIds);
+            const srcType = (0, typeUtils_1.makeTypeVarsBound)(typeResult.type, liveScopeIds);
+            if (!assignType(boundDeclaredType, srcType, diagAddendum)) {
                 // If there was an expected type mismatch, use that diagnostic
                 // addendum because it will be more informative.
                 if (expectedTypeDiagAddendum) {
@@ -2529,7 +2534,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Is this subtype a tuple?
             const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
             if (tupleType && tupleType.priv.tupleTypeArgs) {
-                const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), /* skipSelfCondition */ true));
+                const sourceEntryTypes = tupleType.priv.tupleTypeArgs.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype), { skipSelfCondition: true }));
                 const unboundedIndex = tupleType.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded);
                 if (unboundedIndex >= 0) {
                     if (sourceEntryTypes.length < targetTypes.length) {
@@ -2714,6 +2719,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         useBoundTypeVars: types_1.TypeVarType.isBound(subtype),
                     });
                 }
+                if (subtype.priv.isUnpacked && (0, types_1.isClass)(boundType)) {
+                    boundType = types_1.ClassType.cloneForUnpacked(boundType);
+                }
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
                 return (0, typeUtils_1.addConditionToType)(boundType, [{ typeVar: subtype, constraintIndex: 0 }]);
             }
@@ -2890,11 +2898,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                const annotationType = getTypeOfAnnotation(target.d.annotation, {
+                let annotationType = getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
+                if (annotationType) {
+                    const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
+                    annotationType = (0, typeUtils_1.makeTypeVarsBound)(annotationType, liveScopeIds);
+                }
                 // Handle a bare "Final" or "ClassVar" in a special manner.
                 const isBareFinalOrClassVar = (0, types_1.isClassInstance)(annotationType) &&
                     (types_1.ClassType.isBuiltIn(annotationType, 'Final') || types_1.ClassType.isBuiltIn(annotationType, 'ClassVar'));
@@ -3143,6 +3155,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
             }
+            if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
+                type = validateTypeVarUsage(node, type, flags);
+            }
             // Add TypeForm details if appropriate.
             type = addTypeFormForSymbol(node, type, flags, !!effectiveTypeInfo.includesVariableDecl);
         }
@@ -3156,7 +3171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isParamSpec)(type)) {
+        if ((0, types_1.isParamSpec)(type) && type.priv.scopeId) {
             if (flags & 32 /* EvalFlags.NoParamSpec */) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
@@ -3173,9 +3188,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        if ((0, types_1.isTypeVar)(type) && !type.shared.isSynthesized) {
-            type = validateTypeVarUsage(node, type, flags);
-        }
         return { type, isIncomplete };
     }
     function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
@@ -3231,7 +3243,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             return true;
         }
-        if ((0, types_1.isTypeVar)(type) && !type.priv.scopeId) {
+        if ((0, types_1.isTypeVar)(type)) {
             return true;
         }
         // Exempts class types that are created by calling NewType, NamedTuple, etc.
@@ -3470,7 +3482,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (type.priv.scopeId && !scopedTypeVarInfo.foundInterveningClass) {
                 return type;
             }
-            if (!type.shared.isSynthesized) {
+            if (!type.shared.isSynthesized && (flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
                 const message = (0, types_1.isParamSpec)(type)
                     ? localize_1.LocMessage.paramSpecNotUsedByOuterScope()
                     : localize_1.LocMessage.typeVarNotUsedByOuterScope();
@@ -3531,7 +3543,7 @@ 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;
+        var _a, _b;
         let curNode = node;
         let nestedClassCount = 0;
         (0, debug_1.assert)(types_1.TypeBase.isInstantiable(type));
@@ -3598,7 +3610,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // purposes of resolving type aliases?
                 if (leftType && (0, types_1.isTypeVar)(leftType) && leftType.shared.recursiveAlias) {
                     // Type alias statements cannot be used with old-style type variables.
-                    if (typeAliasNode && !type.shared.isTypeParamSyntax) {
+                    if (typeAliasNode && !type.shared.isTypeParamSyntax && !((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeParameterNotDeclared().format({
                             name: type.shared.name,
                             container: typeAliasNode.d.name.d.value,
@@ -3608,7 +3620,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // If this is a TypeAliasType call, the recursive type parameters will already
                         // be populated, and we need to verify that the type parameter is in the
                         // list of allowed type parameters.
-                        const allowedTypeParams = (_a = leftType.shared.recursiveAlias) === null || _a === void 0 ? void 0 : _a.typeParams;
+                        const allowedTypeParams = (_b = leftType.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.typeParams;
                         if (allowedTypeParams) {
                             if (!allowedTypeParams.some((param) => param.shared.name === type.shared.name)) {
                                 // Return the original type.
@@ -3828,8 +3840,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (typeResult) {
                     if (!typeResult.typeErrors) {
-                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), 
-                        /* skipSelfCondition */ true);
+                        type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                            skipSelfCondition: true,
+                            skipBoundTypeVars: true,
+                        });
                     }
                     else {
                         typeErrors = true;
@@ -3841,8 +3855,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isIncomplete = true;
                     }
                     if (typeResult.narrowedTypeForSet) {
-                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), 
-                        /* skipSelfCondition */ true);
+                        narrowedTypeForSet = (0, typeUtils_1.addConditionToType)(typeResult.narrowedTypeForSet, (0, typeUtils_1.getTypeCondition)(baseType), { skipSelfCondition: true, skipBoundTypeVars: true });
                     }
                     if (typeResult.memberAccessDeprecationInfo) {
                         memberAccessDeprecationInfo = typeResult.memberAccessDeprecationInfo;
@@ -3932,7 +3945,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         (0, debug_1.assert)((0, types_1.isClassInstance)(subtype));
                         const typeResult = getTypeOfBoundMember(node.d.member, subtype, memberName, usage, diag);
                         if (typeResult && !typeResult.typeErrors) {
-                            type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType));
+                            type = (0, typeUtils_1.addConditionToType)(typeResult.type, (0, typeUtils_1.getTypeCondition)(baseType), {
+                                skipBoundTypeVars: true,
+                            });
                             if (typeResult.isIncomplete) {
                                 isIncomplete = true;
                             }
@@ -5542,7 +5557,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
             }
-            adjFlags |= 2097152 /* EvalFlags.AllowUnpackedTuple */ | 134217728 /* EvalFlags.AllowConcatenate */;
+            adjFlags |= 4194304 /* EvalFlags.AllowUnpackedTuple */ | 134217728 /* EvalFlags.AllowConcatenate */;
         }
         // Create a local function that validates a single type argument.
         const getTypeArgTypeResult = (expr, argIndex) => {
@@ -5559,7 +5574,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if ((options === null || options === void 0 ? void 0 : options.isAnnotatedClass) && argIndex > 0) {
                 // If it's an Annotated[a, b, c], only the first index should be
-                // treated as a type.The others can be regular(non - type) objects.
+                // treated as a type. The others can be regular (non-type) objects.
                 adjFlags =
                     32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
                 if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
@@ -5638,10 +5653,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isTypeVar)(type)) {
             const upperBound = type.shared.boundType;
             if (upperBound && (0, types_1.isClassInstance)(upperBound) && (0, typeUtils_1.isTupleClass)(upperBound)) {
-                const concrete = makeTopLevelTypeVarsConcrete(type);
-                if ((0, types_1.isInstantiableClass)(concrete)) {
-                    return types_1.ClassType.cloneForUnpacked(concrete);
-                }
+                return types_1.TypeVarType.cloneForUnpacked(type);
             }
             return undefined;
         }
@@ -5927,6 +5939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isTypeSame)(assertedType, arg0Type, {
             treatAnySameAsUnknown: true,
             ignorePseudoGeneric: true,
+            ignoreConditions: true,
         })) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
@@ -7216,7 +7229,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function evaluateCastCall(argList, errorNode) {
         var _a;
         // Verify that the cast is necessary.
-        const castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
+        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
         let castFromType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
         if ((_a = castFromType.props) === null || _a === void 0 ? void 0 : _a.specialForm) {
             castFromType = castFromType.props.specialForm;
@@ -7449,7 +7464,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const paramInfo = paramDetails.params[paramIndex];
             const paramType = paramInfo.type;
             const paramName = paramInfo.param.name;
-            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isTypeVarTuple)(paramType);
+            const isParamVariadic = paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && (0, types_1.isUnpacked)(paramType);
             if (argList[argIndex].argCategory === 1 /* ArgCategory.UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArg(argList[argIndex], /* inferenceContext */ undefined);
@@ -7581,7 +7596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramType.priv.tupleTypeArgs.length > 0) {
                         effectiveParamType = paramType.priv.tupleTypeArgs[0].type;
                     }
-                    paramCategory = (0, types_1.isTypeVarTuple)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
+                    paramCategory = (0, types_1.isUnpacked)(effectiveParamType) ? 1 /* ParamCategory.ArgsList */ : 0 /* ParamCategory.Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
                             if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -8060,7 +8075,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 !isTypeVarTupleFullyMatched) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-                if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isInUnion) {
+                if ((0, types_1.isUnpacked)(paramType) && (!(0, types_1.isTypeVarTuple)(paramType) || !paramType.priv.isInUnion)) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
                         const argType = getTypeOfArg(argParam.argument, /* inferenceContext */ undefined).type;
@@ -8084,20 +8099,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         };
                     });
                     let specializedTuple;
-                    if (tupleTypeArgs.length === 1 &&
-                        !tupleTypeArgs[0].isUnbounded &&
-                        ((0, types_1.isUnpackedClass)(tupleTypeArgs[0].type) || (0, types_1.isTypeVarTuple)(tupleTypeArgs[0].type))) {
-                        // If there is a single unpacked tuple or unpacked variadic type variable
-                        // (including an unpacked TypeVarTuple union) within this tuple,
-                        // simplify the type.
-                        specializedTuple = tupleTypeArgs[0].type;
+                    if (tupleTypeArgs.length === 1 && !tupleTypeArgs[0].isUnbounded) {
+                        const entryType = tupleTypeArgs[0].type;
+                        if ((0, types_1.isUnpacked)(entryType)) {
+                            specializedTuple = (0, typeUtils_1.makePacked)(entryType);
+                        }
                     }
-                    else {
-                        specializedTuple = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs, /* isUnpacked */ true);
+                    if (!specializedTuple) {
+                        specializedTuple = (0, tuples_1.makeTupleObject)(evaluatorInterface, tupleTypeArgs, /* isUnpacked */ false);
                     }
                     const combinedArg = {
-                        paramCategory: 1 /* ParamCategory.ArgsList */,
-                        paramType,
+                        paramCategory: 0 /* ParamCategory.Simple */,
+                        paramType: (0, typeUtils_1.makePacked)(paramType),
                         requiresTypeVarMatching: true,
                         argument: {
                             argCategory: 0 /* ArgCategory.Simple */,
@@ -8407,7 +8420,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 eliminateUnsolvedInUnions,
             },
         });
-        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
+        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition, { skipBoundTypeVars: true });
         // If the function includes a ParamSpec and the captured signature(s) includes
         // generic types, we may need to apply those solved TypeVars.
         if (paramSpecConstraints.length > 0) {
@@ -8423,7 +8436,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
-            specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpacked */ false);
+            specializedReturnType = types_1.ClassType.cloneForPacked(specializedReturnType);
         }
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
@@ -10690,16 +10703,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // As per the specification, we support None, int, bool, str, bytes literals
         // plus enum values.
         const literalTypes = [];
+        let isValidTypeForm = true;
         for (const item of node.d.items) {
             let type;
             const itemExpr = item.d.valueExpr;
             if (item.d.argCategory !== 0 /* ArgCategory.Simple */) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (item.d.name) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.keywordArgInTypeArgument(), itemExpr);
+                    type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
+                }
             }
             else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
                 const isBytes = (itemExpr.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
@@ -10710,11 +10730,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     type = cloneBuiltinClassWithLiteral(node, classType, 'str', value);
                 }
-                itemExpr.d.strings.forEach((stringNode) => {
-                    if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
-                    }
-                });
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    itemExpr.d.strings.forEach((stringNode) => {
+                        if ((stringNode.d.token.flags & 512 /* StringTokenFlags.NamedUnicodeEscape */) !== 0) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNamedUnicodeEscape(), stringNode);
+                            isValidTypeForm = false;
+                        }
+                    });
+                }
             }
             else if (itemExpr.nodeType === 40 /* ParseNodeType.Number */) {
                 if (!itemExpr.d.isImaginary && itemExpr.d.isInteger) {
@@ -10770,6 +10793,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
                     type = types_1.UnknownType.create();
+                    isValidTypeForm = false;
                 }
                 else {
                     return types_1.ClassType.cloneAsInstance(classType);
@@ -10781,7 +10805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(result) && unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             result = types_1.TypeBase.cloneAsSpecialForm(result, types_1.ClassType.cloneAsInstance(unionTypeClass));
         }
-        if (isTypeFormSupported(node)) {
+        if (isTypeFormSupported(node) && isValidTypeForm) {
             result = types_1.TypeBase.cloneWithTypeForm(result, (0, typeUtils_1.convertToInstance)(result));
         }
         return result;
@@ -10952,13 +10976,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isUsageLegal = true;
             }
         }
-        if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
-            isUsageLegal = true;
-        }
         let isReadOnly = typeArgs[0].isReadOnly;
         let isRequired = typeArgs[0].isRequired;
         let isNotRequired = typeArgs[0].isNotRequired;
         if (classType.shared.name === 'ReadOnly') {
+            if ((flags & 2097152 /* EvalFlags.AllowReadOnly */) !== 0) {
+                isUsageLegal = true;
+            }
             // Nested ReadOnly are not allowed.
             if (typeArgs[0].isReadOnly) {
                 isUsageLegal = false;
@@ -10966,6 +10990,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isReadOnly = true;
         }
         else {
+            if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
+                isUsageLegal = true;
+            }
             // Nested Required/NotRequired are not allowed.
             if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
                 isUsageLegal = false;
@@ -10993,7 +11020,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return classType;
         }
         const typeArgType = typeArgs[0].type;
-        if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
+        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
             const unpackedType = applyUnpackToTupleLike(typeArgType);
             if (unpackedType) {
                 return unpackedType;
@@ -11004,7 +11031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
             return types_1.UnknownType.create();
         }
-        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
+        if ((flags & 8388608 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
@@ -11641,8 +11668,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!rightHandType) {
-            // Determine whether there is a declared type.
-            const declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
             let typeAliasNameNode;
             let typeAliasPlaceholder;
             let isSpeculativeTypeAlias = false;
@@ -11686,6 +11711,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     writeTypeCache(node.d.leftExpr.d.valueExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 }
             }
+            let declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
+            if (declaredType) {
+                const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
+            }
             const srcTypeResult = getTypeOfExpression(node.d.rightExpr, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
             rightHandType = srcTypeResult.type;
             expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
@@ -12125,6 +12155,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                                 classType.shared.flags |=
                                     8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                if (classType.shared.typedDictExtraItemsExpr) {
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
+                                }
+                            }
+                        }
+                    }
+                    else if (arg.d.name.d.value === 'extra_items') {
+                        // This is an experimental feature because PEP 728 hasn't been accepted yet.
+                        if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                            // Record a reference to the expression but don't evaluate it yet.
+                            // It may refer to the class itself.
+                            classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                            classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                            if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                             }
                         }
                     }
@@ -13328,7 +13373,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return type;
                 }
                 if ((0, types_1.isUnpackedClass)(type)) {
-                    return types_1.ClassType.cloneForUnpacked(type, /* isUnpacked */ false);
+                    return types_1.ClassType.cloneForPacked(type);
                 }
                 return (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type, isUnbounded: !(0, types_1.isTypeVarTuple)(type) }]);
             }
@@ -13337,9 +13382,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
                     return type;
                 }
-                // Is this an unpacked TypedDict? If so, return it unmodified.
+                // Is this an unpacked TypedDict? If so, return its packed version.
                 if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isTypedDictClass(type) && type.priv.isUnpacked) {
-                    return type;
+                    return types_1.ClassType.cloneForPacked(type);
                 }
                 // Wrap the type in a dict with str keys.
                 const dictType = getBuiltInType(node, 'dict');
@@ -14953,7 +14998,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             flags |= 4 /* EvalFlags.ForwardRefs */;
         }
         else if (options === null || options === void 0 ? void 0 : options.parsesStringLiteral) {
-            flags |= 8388608 /* EvalFlags.ParsesStringLiteral */;
+            flags |= 16777216 /* EvalFlags.ParsesStringLiteral */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
             flags |= 16 /* EvalFlags.NoFinal */;
@@ -14961,14 +15006,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
             flags |= 1048576 /* EvalFlags.AllowRequired */ | 256 /* EvalFlags.TypeExpression */;
         }
+        if (options === null || options === void 0 ? void 0 : options.allowReadOnly) {
+            flags |= 2097152 /* EvalFlags.AllowReadOnly */ | 256 /* EvalFlags.TypeExpression */;
+        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
-            flags |= 2097152 /* EvalFlags.AllowUnpackedTuple */;
+            flags |= 4194304 /* EvalFlags.AllowUnpackedTuple */;
         }
         else {
             flags |= 64 /* EvalFlags.NoTypeVarTuple */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
-            flags |= 4194304 /* EvalFlags.AllowUnpackedTypedDict */;
+            flags |= 8388608 /* EvalFlags.AllowUnpackedTypedDict */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
             flags |= 32 /* EvalFlags.NoParamSpec */;
@@ -15419,7 +15467,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (paramDecl) {
                                 declarations.push(paramDecl);
                             }
-                            else if (types_1.ClassType.isDataClass(baseType) || types_1.ClassType.isTypedDictClass(baseType)) {
+                            else if (types_1.ClassType.isDataClass(baseType) ||
+                                types_1.ClassType.isTypedDictClass(baseType) ||
+                                types_1.ClassType.hasNamedTupleEntry(baseType, paramName)) {
                                 const lookupResults = (0, typeUtils_1.lookUpClassMember)(baseType, paramName);
                                 if (lookupResults) {
                                     (0, collectionUtils_1.appendArray)(declarations, lookupResults.symbol.getDeclarations());
@@ -15549,6 +15599,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
                             allowFinal: true,
                             allowRequired: true,
+                            allowReadOnly: true,
                         }).type);
                     }
                     else {
@@ -15561,6 +15612,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
                             allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
                             allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                            allowReadOnly: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
                             enforceClassTypeVarScope: declaration.isDefinedByMemberAccess,
                         });
                     }
@@ -16240,23 +16292,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // cases where a property symbol is redefined to add a setter, deleter,
         // etc.
         if (usageNode && typedDecls.length > 1) {
-            const filteredTypedDecls = typedDecls.filter((decl) => {
-                if (decl.type !== 8 /* DeclarationType.Alias */) {
-                    // Is the declaration in the same execution scope as the "usageNode" node?
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
-                    if (usageScope === declScope) {
-                        if (!isFlowPathBetweenNodes(decl.node, usageNode, /* allowSelf */ false)) {
-                            return false;
+            if (typedDecls.length > maxTypedDeclsPerSymbol) {
+                // If there are too many typed decls, don't bother filtering them
+                // because this can be very expensive. Simply use the last one
+                // in this case.
+                typedDecls = [typedDecls[typedDecls.length - 1]];
+            }
+            else {
+                const filteredTypedDecls = typedDecls.filter((decl) => {
+                    if (decl.type !== 8 /* DeclarationType.Alias */) {
+                        // Is the declaration in the same execution scope as the "usageNode" node?
+                        const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
+                        const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
+                        if (usageScope === declScope) {
+                            if (!isFlowPathBetweenNodes(decl.node, usageNode, /* allowSelf */ false)) {
+                                return false;
+                            }
                         }
                     }
+                    return true;
+                });
+                if (filteredTypedDecls.length === 0) {
+                    return { type: types_1.UnboundType.create() };
                 }
-                return true;
-            });
-            if (filteredTypedDecls.length === 0) {
-                return { type: types_1.UnboundType.create() };
+                typedDecls = filteredTypedDecls;
             }
-            typedDecls = filteredTypedDecls;
         }
         // Start with the last decl. If that's already being resolved,
         // use the next-to-last decl, etc. This can happen when resolving
@@ -17404,6 +17464,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
+                // Handle the case where the source is an unpacked tuple.
+                if (!destType.priv.isUnpacked &&
+                    concreteSrcType.priv.isUnpacked &&
+                    concreteSrcType.priv.tupleTypeArgs) {
+                    return assignType(destType, (0, typeUtils_1.combineTupleTypeArgs)(concreteSrcType.priv.tupleTypeArgs), diag, constraints, flags, recursionCount);
+                }
                 // Handle enum literals that are assignable to another (non-Enum) literal.
                 // This can happen for IntEnum and StrEnum members.
                 if (types_1.ClassType.isEnumClass(concreteSrcType) &&
@@ -18322,11 +18388,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const destParamName = (_c = destParam.param.name) !== null && _c !== void 0 ? _c : '';
             const srcParamName = (_d = srcParam.param.name) !== null && _d !== void 0 ? _d : '';
             if (destParamName) {
-                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional;
+                const isDestPositionalOnly = destParam.kind === parameterUtils_1.ParamKind.Positional || destParam.kind === parameterUtils_1.ParamKind.ExpandedArgs;
                 if (!isDestPositionalOnly &&
                     destParam.param.category !== 1 /* ParamCategory.ArgsList */ &&
                     srcParam.param.category !== 1 /* ParamCategory.ArgsList */) {
-                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional) {
+                    if (srcParam.kind === parameterUtils_1.ParamKind.Positional || srcParam.kind === parameterUtils_1.ParamKind.ExpandedArgs) {
                         diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamPositionOnly().format({
                             name: destParamName,
                         }));
@@ -18381,6 +18447,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (destParam.kind !== parameterUtils_1.ParamKind.Positional &&
+                destParam.kind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                 srcParam.kind === parameterUtils_1.ParamKind.Positional &&
                 srcParamDetails.kwargsIndex === undefined &&
                 !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword &&
@@ -18469,7 +18536,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                             canAssign = false;
                         }
-                        if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParamKind.Positional &&
+                        const destParamKind = destParamDetails.params[paramIndex].kind;
+                        if (destParamKind !== parameterUtils_1.ParamKind.Positional &&
+                            destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                             srcParamDetails.kwargsIndex === undefined) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
                                 name: (_g = destParamDetails.params[paramIndex].param.name) !== null && _g !== void 0 ? _g : '',
@@ -18543,7 +18612,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (index >= destParamDetails.firstKeywordOnlyIndex) {
                         if (param.param.name &&
                             param.param.category === 0 /* ParamCategory.Simple */ &&
-                            param.kind !== parameterUtils_1.ParamKind.Positional) {
+                            param.kind !== parameterUtils_1.ParamKind.Positional &&
+                            param.kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                             destParamMap.set(param.param.name, param);
                         }
                     }
@@ -19150,7 +19220,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
                     if (!types_1.FunctionParam.isNameSynthesized(baseParam) &&
-                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional) {
+                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.Positional &&
+                        baseParamDetails.params[i].kind !== parameterUtils_1.ParamKind.ExpandedArgs) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNamePositionOnly().format({
                             index: i + 1,
                             baseName: baseParam.name || '*',