@zzzen/pyright-internal 1.2.0-dev.20241013 → 1.2.0-dev.20241027

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 */;
@@ -2017,7 +2022,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // Handle the case where the type is synthesized (used for
                         // dataclasses).
                         if (synthesizedType) {
-                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType);
+                            isObjectHashable = !(0, typeUtils_1.isNoneInstance)(synthesizedType.type);
                         }
                         else {
                             // Assume that if '__hash__' is declared as a variable, it is
@@ -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) {
@@ -3538,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));
@@ -3605,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,
@@ -3615,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.
@@ -3835,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;
@@ -3848,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;
@@ -3939,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;
                             }
@@ -5549,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) => {
@@ -5931,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({
@@ -7301,13 +7310,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            var _a, _b;
             (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* ParamCategory.Simple */ && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                paramMap.set(param.name, {
-                    argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType ? 1 : 0,
-                    argsReceived: 0,
-                });
+                let argsNeeded = (_b = (_a = paramMap.get(param.name)) === null || _a === void 0 ? void 0 : _a.argsNeeded) !== null && _b !== void 0 ? _b : 0;
+                if (param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType) {
+                    argsNeeded += 1;
+                }
+                paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
             }
         });
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
@@ -8360,11 +8371,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (paramSpec) {
                 if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */) {
                     if ((0, parameterUtils_1.isParamSpecArgs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecArgs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecArgs = true;
                     }
                 }
                 if (argParam.argument.argCategory === 2 /* ArgCategory.UnpackedDictionary */) {
                     if ((0, parameterUtils_1.isParamSpecKwargs)(paramSpec, argResult.argType)) {
+                        if (sawParamSpecKwargs) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramSpecArgsKwargsDuplicate().format({ type: printType(paramSpec) }), argParam.errorNode);
+                        }
                         sawParamSpecKwargs = true;
                     }
                 }
@@ -8411,7 +8428,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) {
@@ -10967,13 +10984,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;
@@ -10981,6 +10998,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;
@@ -11008,7 +11028,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;
@@ -11019,7 +11039,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);
             }
@@ -12143,6 +12163,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);
                             }
                         }
                     }
@@ -13355,9 +13390,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');
@@ -14971,7 +15006,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 */;
@@ -14979,14 +15014,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 */;
@@ -15058,15 +15096,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Filter the declarations based on flow reachability.
             const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* DeclarationType.Alias */ && decl.type !== 0 /* DeclarationType.Intrinsic */) {
-                    // Is the declaration in the same execution scope as the "usageNode" node?
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(node);
+                    // Determine if the declaration is in the same execution scope as the "usageNode" node.
+                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
                     const declNode = decl.type === 6 /* DeclarationType.Class */ ||
                         decl.type === 5 /* DeclarationType.Function */ ||
                         decl.type === 4 /* DeclarationType.TypeAlias */
                         ? decl.node.d.name
                         : decl.node;
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(declNode);
-                    if (usageScope === declScope) {
+                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode);
+                    // If this is a type parameter scope, it will be a proxy for its
+                    // containing scope, so we need to use that instead.
+                    const usageScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                    if (usageScope === null || usageScope === void 0 ? void 0 : usageScope.proxy) {
+                        const typeParamScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                        if (!(typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.has(name)) && usageScopeNode.parent) {
+                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent);
+                        }
+                    }
+                    if (usageScopeNode === declScopeNode) {
                         if (!isFlowPathBetweenNodes(declNode, node)) {
                             // If there was no control flow path from the usage back
                             // to the source, see if the usage node is reachable by
@@ -15273,7 +15320,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // dictionary expression where those keys are associated with a known TypedDict.
     function getDeclInfoForStringNode(node) {
         var _a;
-        const declarations = [];
+        const decls = [];
+        const synthesizedTypes = [];
         const expectedType = (_a = getExpectedType(node)) === null || _a === void 0 ? void 0 : _a.type;
         if (expectedType) {
             (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
@@ -15287,13 +15335,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (entry) {
                         const symbol = (_b = (0, typeUtils_1.lookUpObjectMember)(subtype, node.d.value)) === null || _b === void 0 ? void 0 : _b.symbol;
                         if (symbol) {
-                            (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                            const synthTypeInfo = symbol.getSynthesizedType();
+                            if (synthTypeInfo) {
+                                synthesizedTypes.push(synthTypeInfo);
+                            }
                         }
                     }
                 }
             });
         }
-        return declarations.length === 0 ? undefined : { decls: declarations, synthesizedTypes: [] };
+        return decls.length === 0 ? undefined : { decls, synthesizedTypes };
     }
     function getAliasFromImport(node) {
         if (node.parent &&
@@ -15309,7 +15361,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
-        const declarations = [];
+        const decls = [];
         const synthesizedTypes = [];
         // If the node is part of a "from X import Y as Z" statement and the node
         // is the "Y" (non-aliased) name, we need to look up the alias symbol
@@ -15326,7 +15378,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const declsForThisImport = symbolInScope.symbol.getDeclarations().filter((decl) => {
                         return decl.type === 8 /* DeclarationType.Alias */ && decl.node === node.parent;
                     });
-                    (0, collectionUtils_1.appendArray)(declarations, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
+                    (0, collectionUtils_1.appendArray)(decls, (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsForThisImport));
                 }
             }
         }
@@ -15377,16 +15429,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // which includes every assignment of that symbol.
                         const typedDecls = symbol.getTypedDeclarations();
                         if (typedDecls.length > 0) {
-                            (0, collectionUtils_1.appendArray)(declarations, typedDecls);
+                            (0, collectionUtils_1.appendArray)(decls, typedDecls);
                         }
                         else {
-                            const synthesizedType = symbol.getSynthesizedType();
-                            if (synthesizedType) {
-                                synthesizedTypes.push({ type: synthesizedType, node });
-                            }
-                            else {
-                                (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
-                            }
+                            (0, collectionUtils_1.appendArray)(decls, symbol.getDeclarations());
+                        }
+                        const synthTypeInfo = symbol.getSynthesizedType();
+                        if (synthTypeInfo) {
+                            synthesizedTypes.push(synthTypeInfo);
                         }
                     }
                 });
@@ -15404,7 +15454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Synthesize an alias declaration for this name part. The only
                     // time this case is used is for IDE services such as
                     // the find all references, hover provider and etc.
-                    declarations.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
+                    decls.push((0, declarationUtils_1.synthesizeAliasDeclaration)(importInfo.resolvedUris[namePartIndex]));
                 }
             }
         }
@@ -15419,14 +15469,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
                         const paramDecl = getDeclarationFromKeywordParam(baseType, paramName);
                         if (paramDecl) {
-                            declarations.push(paramDecl);
+                            decls.push(paramDecl);
                         }
                     }
                     else if ((0, types_1.isOverloaded)(baseType)) {
                         types_1.OverloadedType.getOverloads(baseType).forEach((f) => {
                             const paramDecl = getDeclarationFromKeywordParam(f, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                         });
                     }
@@ -15435,14 +15485,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
                             if (paramDecl) {
-                                declarations.push(paramDecl);
+                                decls.push(paramDecl);
                             }
                             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());
+                                    (0, collectionUtils_1.appendArray)(decls, lookupResults.symbol.getDeclarations());
+                                    const synthTypeInfo = lookupResults.symbol.getSynthesizedType();
+                                    if (synthTypeInfo) {
+                                        synthesizedTypes.push(synthTypeInfo);
+                                    }
                                 }
                             }
                         }
@@ -15467,10 +15521,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
             const symbolWithScope = lookUpSymbolRecursive(node, node.d.value, !allowForwardReferences, isWithinTypeAnnotation);
             if (symbolWithScope) {
-                (0, collectionUtils_1.appendArray)(declarations, symbolWithScope.symbol.getDeclarations());
+                (0, collectionUtils_1.appendArray)(decls, symbolWithScope.symbol.getDeclarations());
+                const synthTypeInfo = symbolWithScope.symbol.getSynthesizedType();
+                if (synthTypeInfo) {
+                    synthesizedTypes.push(synthTypeInfo);
+                }
             }
         }
-        return { decls: declarations, synthesizedTypes };
+        return { decls, synthesizedTypes };
     }
     function getTypeForDeclaration(declaration) {
         var _a, _b, _c;
@@ -15569,6 +15627,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         declaredType = (0, typeUtils_1.convertToInstance)(getTypeOfExpressionExpectingType(typeAnnotationNode, {
                             allowFinal: true,
                             allowRequired: true,
+                            allowReadOnly: true,
                         }).type);
                     }
                     else {
@@ -15581,6 +15640,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,
                         });
                     }
@@ -16238,7 +16298,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // provided, but type inference is still required. In such cases, the attributes
     // are returned as flags.
     function getDeclaredTypeOfSymbol(symbol, usageNode) {
-        const synthesizedType = symbol.getSynthesizedType();
+        var _a;
+        const synthesizedType = (_a = symbol.getSynthesizedType()) === null || _a === void 0 ? void 0 : _a.type;
         if (synthesizedType) {
             return { type: synthesizedType };
         }
@@ -16260,23 +16321,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
@@ -16844,41 +16913,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Now handle generic base classes.
             destType.shared.baseClasses.forEach((baseClass) => {
-                if ((0, types_1.isInstantiableClass)(baseClass) &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'object') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Protocol') &&
-                    !types_1.ClassType.isBuiltIn(baseClass, 'Generic') &&
-                    baseClass.shared.typeParams.length > 0) {
-                    const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
-                    const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-                    if (!ignoreBaseClassVariance) {
-                        specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
-                            if (!(0, types_1.isParamSpec)(param) &&
-                                !(0, types_1.isTypeVarTuple)(param) &&
-                                !param.shared.isSynthesized &&
-                                specializedSrcBaseClass.priv.typeArgs &&
-                                index < specializedSrcBaseClass.priv.typeArgs.length &&
-                                specializedDestBaseClass.priv.typeArgs &&
-                                index < specializedDestBaseClass.priv.typeArgs.length) {
-                                const paramVariance = param.shared.declaredVariance;
-                                if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ ||
-                                        paramVariance === 4 /* Variance.Contravariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
-                                else if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
-                                    if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
-                                        isAssignable = false;
-                                    }
-                                }
+                if (!isAssignable ||
+                    !(0, types_1.isInstantiableClass)(baseClass) ||
+                    types_1.ClassType.isBuiltIn(baseClass, ['object', 'Protocol', 'Generic']) ||
+                    baseClass.shared.typeParams.length === 0) {
+                    return;
+                }
+                const specializedDestBaseClass = (0, typeUtils_1.specializeForBaseClass)(destType, baseClass);
+                const specializedSrcBaseClass = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+                if (!ignoreBaseClassVariance) {
+                    specializedDestBaseClass.shared.typeParams.forEach((param, index) => {
+                        if ((0, types_1.isParamSpec)(param) || (0, types_1.isTypeVarTuple)(param) || param.shared.isSynthesized) {
+                            return;
+                        }
+                        if (!specializedSrcBaseClass.priv.typeArgs ||
+                            index >= specializedSrcBaseClass.priv.typeArgs.length ||
+                            !specializedDestBaseClass.priv.typeArgs ||
+                            index >= specializedDestBaseClass.priv.typeArgs.length) {
+                            return;
+                        }
+                        const paramVariance = param.shared.declaredVariance;
+                        if ((0, types_1.isTypeVar)(specializedSrcBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 4 /* Variance.Contravariant */) {
+                                isAssignable = false;
+                                return;
                             }
-                        });
-                    }
-                    if (isAssignable &&
-                        !assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
-                        isAssignable = false;
-                    }
+                        }
+                        if ((0, types_1.isTypeVar)(specializedDestBaseClass.priv.typeArgs[index])) {
+                            if (paramVariance === 2 /* Variance.Invariant */ || paramVariance === 3 /* Variance.Covariant */) {
+                                isAssignable = false;
+                                return;
+                            }
+                        }
+                    });
+                }
+                if (!isAssignable) {
+                    return;
+                }
+                // Handle tuples specially since their type arguments are variadic.
+                if (types_1.ClassType.isTupleClass(specializedDestBaseClass)) {
+                    return;
+                }
+                if (!assignClassToSelf(specializedDestBaseClass, specializedSrcBaseClass, assumedVariance, ignoreBaseClassVariance, recursionCount)) {
+                    isAssignable = false;
                 }
             });
             return isAssignable;
@@ -18407,6 +18484,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 &&
@@ -18495,7 +18573,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 : '',
@@ -18569,7 +18649,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);
                         }
                     }
@@ -19176,7 +19257,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 || '*',