@zzzen/pyright-internal 1.2.0-dev.20230514 → 1.2.0-dev.20230528

package/dist/analyzer/typeEvaluator.js

@@ -166,7 +166,7 @@ const printExpressionTypes = false;
 exports.maxCodeComplexity = 768;
 function createTypeEvaluator(importLookup, evaluatorOptions) {
     const symbolResolutionStack = [];
-    const asymmetricDescriptorAssignmentCache = new Set();
+    const asymmetricAccessorAssignmentCache = new Set();
     const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
     let functionRecursionMap = new Set();
@@ -300,10 +300,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (isSpeculativeModeInUse(/* node */ undefined)) {
             return;
         }
-        asymmetricDescriptorAssignmentCache.add(node.id);
+        asymmetricAccessorAssignmentCache.add(node.id);
     }
-    function isAsymmetricDescriptorAssignment(node) {
-        return asymmetricDescriptorAssignmentCache.has(node.id);
+    function isAsymmetricAccessorAssignment(node) {
+        return asymmetricAccessorAssignmentCache.has(node.id);
     }
     // Determines whether the specified node is contained within
     // the function node corresponding to the function that we
@@ -822,7 +822,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let isLiteralString = true;
             // If all of the format expressions are of type LiteralString, then
             // the resulting formatted string is also LiteralString.
-            node.expressions.forEach((expr) => {
+            node.fieldExpressions.forEach((expr) => {
                 const exprType = getTypeOfExpression(expr).type;
                 (0, typeUtils_1.doForEachSubtype)(exprType, (exprSubtype) => {
                     if (!(0, types_1.isClassInstance)(exprSubtype)) {
@@ -858,6 +858,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeResult;
     }
     function stripLiteralValue(type) {
+        var _a, _b, _c;
+        // Handle the not-uncommon case where the type is a union that consists
+        // only of literal str or literal int values.
+        if ((0, types_1.isUnion)(type) && type.subtypes.length > 0) {
+            if (((_a = type.literalStrMap) === null || _a === void 0 ? void 0 : _a.size) === type.subtypes.length ||
+                ((_b = type.literalIntMap) === null || _b === void 0 ? void 0 : _b.size) === type.subtypes.length ||
+                ((_c = type.literalEnumMap) === null || _c === void 0 ? void 0 : _c.size) === type.subtypes.length) {
+                return stripLiteralValue(type.subtypes[0]);
+            }
+        }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClass)(subtype)) {
                 if (subtype.literalValue !== undefined) {
@@ -880,9 +890,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfParameterAnnotation(paramTypeNode, paramCategory) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
-            allowTypeVarTuple: paramCategory === 1 /* VarArgList */,
-            allowUnpackedTypedDict: paramCategory === 2 /* VarArgDictionary */,
-            allowUnpackedTuple: paramCategory === 1 /* VarArgList */,
+            allowTypeVarTuple: paramCategory === 1 /* ArgsList */,
+            allowUnpackedTypedDict: paramCategory === 2 /* KwargsDict */,
+            allowUnpackedTuple: paramCategory === 1 /* ArgsList */,
         });
     }
     function getTypeOfAnnotation(node, options) {
@@ -1225,7 +1235,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: memberInfo.type,
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
-                isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
+                isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
             };
         }
         return undefined;
@@ -1272,7 +1282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return {
                 type: memberInfo.type,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
-                isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
+                isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
             };
         }
         // Determine whether to use the class or metaclass diagnostic addendum.
@@ -2102,7 +2112,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             setErrorNode: srcExpr,
             setExpectedTypeDiag: expectedTypeDiagAddendum,
         }, 0 /* None */);
-        if (setTypeResult.isAsymmetricDescriptor) {
+        if (setTypeResult.isAsymmetricAccessor) {
             setAsymmetricDescriptorAssignment(target);
         }
         writeTypeCache(target.memberName, { type, isIncomplete: isTypeIncomplete }, 0 /* None */);
@@ -2322,6 +2332,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // If this is a TypeVarTuple *Ts, convert it to an unpacked tuple
             // *tuple[*Ts].
             if ((0, types_1.isVariadicTypeVar)(subtype)) {
+                if (subtype.isVariadicInUnion) {
+                    return subtype;
+                }
                 if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                     return (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: subtype, isUnbounded: false }], 
                     /* isTypeArgumentExplicit */ true, 
@@ -3295,7 +3308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         let type;
         let isIncomplete = !!baseTypeResult.isIncomplete;
-        let isAsymmetricDescriptor;
+        let isAsymmetricAccessor;
         const isRequired = false;
         const isNotRequired = false;
         // If the base type was incomplete and unbound, don't proceed
@@ -3335,7 +3348,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (baseType.details.isParamSpec) {
                     if (memberName === 'args') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 1 /* VarArgList */) {
+                        if (!paramNode || paramNode.category !== 1 /* ArgsList */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecArgsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -3343,7 +3356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     if (memberName === 'kwargs') {
                         const paramNode = ParseTreeUtils.getEnclosingParameter(node);
-                        if (!paramNode || paramNode.category !== 2 /* VarArgDictionary */) {
+                        if (!paramNode || paramNode.category !== 2 /* KwargsDict */) {
                             addError(localize_1.Localizer.Diagnostic.paramSpecKwargsUsage(), node);
                             return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                         }
@@ -3354,7 +3367,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     return { type: types_1.UnknownType.create(isIncomplete), isIncomplete };
                 }
-                if (flags & 128 /* ExpectingType */) {
+                if (flags & 256 /* ExpectingTypeAnnotation */) {
                     if (!isIncomplete) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNoMember().format({
                             type: printType(baseType),
@@ -3379,8 +3392,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
                         isIncomplete = true;
                     }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricDescriptor) {
-                        isAsymmetricDescriptor = true;
+                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
+                        isAsymmetricAccessor = true;
                     }
                 }
                 else {
@@ -3397,8 +3410,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete) {
                         isIncomplete = true;
                     }
-                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricDescriptor) {
-                        isAsymmetricDescriptor = true;
+                    if (typeResult === null || typeResult === void 0 ? void 0 : typeResult.isAsymmetricAccessor) {
+                        isAsymmetricAccessor = true;
                     }
                 }
                 break;
@@ -3598,7 +3611,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 /* ignoreEmptyContainers */ false);
             }
         }
-        return { type, isIncomplete, isAsymmetricDescriptor, isRequired, isNotRequired };
+        return { type, isIncomplete, isAsymmetricAccessor, isRequired, isNotRequired };
     }
     function getTypeOfClassMemberName(errorNode, classType, isAccessedThroughObject, memberName, usage, diag, flags, bindToType) {
         var _a, _b;
@@ -3733,7 +3746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 isClassMember: !memberInfo.isInstanceMember,
                 isClassVar: memberInfo.isClassVar,
                 classType: memberInfo.classType,
-                isAsymmetricDescriptor: descriptorResult.isAsymmetricDescriptor,
+                isAsymmetricAccessor: descriptorResult.isAsymmetricAccessor,
             };
         }
         // No attribute of that name was found. If this is a member access
@@ -3745,11 +3758,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (generalAttrType) {
                 return {
                     symbol: undefined,
-                    type: generalAttrType,
+                    type: generalAttrType.type,
                     isTypeIncomplete: false,
                     isClassMember: false,
                     isClassVar: false,
-                    isAsymmetricDescriptor: false,
+                    isAsymmetricAccessor: generalAttrType.isAsymmetricAccessor,
                 };
             }
         }
@@ -3762,7 +3775,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function applyDescriptorAccessMethod(type, memberInfo, baseTypeClass, bindToType, isAccessedThroughObject, flags, errorNode, memberName, usage, diag) {
         const treatConstructorAsClassMember = (flags & 16 /* TreatConstructorAsClassMethod */) !== 0;
         let isTypeValid = true;
-        let isAsymmetricDescriptor = false;
+        let isAsymmetricAccessor = false;
         type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             var _a, _b, _c;
             const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
@@ -3947,7 +3960,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // Determine if we're calling __set__ on an asymmetric descriptor or property.
                             if (usage.method === 'set' && (0, types_1.isClass)(accessMethod.classType)) {
                                 if (isAsymmetricDescriptorClass(accessMethod.classType)) {
-                                    isAsymmetricDescriptor = true;
+                                    isAsymmetricAccessor = true;
                                 }
                             }
                             if (returnType) {
@@ -4051,7 +4064,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeValid) {
             return undefined;
         }
-        return { type, isAsymmetricDescriptor };
+        return { type, isAsymmetricAccessor };
     }
     function isAsymmetricDescriptorClass(classType) {
         var _a;
@@ -4085,6 +4098,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         classType.isAsymmetricDescriptor = isAsymmetric;
         return isAsymmetric;
     }
+    function isClassWithAsymmetricAttributeAccessor(classType) {
+        var _a;
+        // If the value has already been cached in this type, return the cached value.
+        if (classType.isAsymmetricAttributeAccessor !== undefined) {
+            return classType.isAsymmetricAttributeAccessor;
+        }
+        let isAsymmetric = false;
+        const getterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__getattr__', 2 /* SkipBaseClasses */);
+        const setterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__setattr__', 2 /* SkipBaseClasses */);
+        if (!getterSymbolResult || !setterSymbolResult) {
+            isAsymmetric = false;
+        }
+        else {
+            const getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
+            const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
+            // If either the setter or getter is an overload (or some other non-function type),
+            // conservatively assume that it's not asymmetric.
+            if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
+                // If there's no declared return type on the getter, assume it's symmetric.
+                if (setterType.details.parameters.length >= 3 && getterType.details.declaredReturnType) {
+                    const setterValueType = types_1.FunctionType.getEffectiveParameterType(setterType, 2);
+                    const getterReturnType = (_a = types_1.FunctionType.getSpecializedReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
+                    if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
+                        isAsymmetric = true;
+                    }
+                }
+            }
+        }
+        // Cache the value for next time.
+        classType.isAsymmetricAttributeAccessor = isAsymmetric;
+        return isAsymmetric;
+    }
     // Applies the __getattr__, __setattr__ or __delattr__ method if present.
     function applyAttributeAccessOverride(classType, errorNode, usage, memberName) {
         var _a, _b, _c, _d, _e;
@@ -4139,7 +4184,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(boundMethodType));
                     const callResult = validateCallArguments(errorNode, argList, { type: boundMethodType }, typeVarContext, 
                     /* skipUnknownArgCheck */ true);
-                    return (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
+                    let isAsymmetricAccessor = false;
+                    if (usage.method === 'set') {
+                        isAsymmetricAccessor = isClassWithAsymmetricAttributeAccessor(classType);
+                    }
+                    return {
+                        type: (_e = callResult.returnType) !== null && _e !== void 0 ? _e : types_1.UnknownType.create(),
+                        isAsymmetricAccessor,
+                    };
                 }
             }
         }
@@ -4475,6 +4527,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = baseTypeResult.isIncomplete;
         let isRequired = false;
         let isNotRequired = false;
+        let isReadOnly = false;
         const type = mapSubtypesExpandTypeVars(baseTypeResult.type, 
         /* conditionFilter */ undefined, (concreteSubtype, unexpandedSubtype) => {
             var _a;
@@ -4581,6 +4634,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 else if (result.isNotRequired) {
                     isNotRequired = true;
                 }
+                if (result.isReadOnly) {
+                    isReadOnly = true;
+                }
                 return result.type;
             }
             if ((0, types_1.isClassInstance)(concreteSubtype)) {
@@ -4612,7 +4668,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             });
         }
-        return { type, isIncomplete, isRequired, isNotRequired };
+        return { type, isIncomplete, isReadOnly, isRequired, isNotRequired };
     }
     // Determines the effective variance of the type parameters for a generic
     // type alias. Normally, variance is not important for type aliases, but
@@ -6077,7 +6133,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
-                    overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
+                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
                     if (functionResult.argumentErrors) {
                         argumentErrors = true;
                     }
@@ -6123,7 +6179,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return (0, typeUtils_1.convertToInstance)(castToType);
                     }
                     const functionResult = validateOverloadedFunctionArguments(errorNode, argList, { type: expandedSubtype, isIncomplete: callTypeResult.isIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
-                    overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
+                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
                     if (functionResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
@@ -6265,7 +6321,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         // Assume this is a call to the constructor.
                         const constructorResult = (0, constructors_1.validateConstructorArguments)(evaluatorInterface, errorNode, argList, expandedSubtype, skipUnknownArgCheck, inferenceContext);
-                        overloadsUsedForCall.push(...constructorResult.overloadsUsedForCall);
+                        (0, collectionUtils_1.appendArray)(overloadsUsedForCall, constructorResult.overloadsUsedForCall);
                         if (constructorResult.argumentErrors) {
                             argumentErrors = true;
                         }
@@ -6308,7 +6364,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _e === void 0 ? void 0 : _e.type;
                         if (memberType) {
                             const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
-                            overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
+                            (0, collectionUtils_1.appendArray)(overloadsUsedForCall, functionResult.overloadsUsedForCall);
                             if (functionResult.argumentErrors) {
                                 argumentErrors = true;
                             }
@@ -6353,7 +6409,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 case 10 /* TypeVar */: {
                     expandedSubtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedSubtype);
                     const callResult = validateCallArguments(errorNode, argList, { type: expandedSubtype }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
-                    overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, callResult.overloadsUsedForCall);
                     if (callResult.argumentErrors) {
                         argumentErrors = true;
                     }
@@ -6441,6 +6497,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Build a map of parameters by name.
         const paramMap = new Map();
         paramDetails.params.forEach((paramInfo) => {
+            (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* Simple */) {
                 paramMap.set(param.name, {
@@ -6491,8 +6548,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (argList.some((arg) => arg.argumentCategory === 1 /* UnpackedList */)) {
             argList.forEach((arg) => {
                 if (arg.name) {
-                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => paramInfo.param.name === arg.name.value &&
-                        paramInfo.param.category === 0 /* Simple */);
+                    const keywordParamIndex = paramDetails.params.findIndex((paramInfo) => {
+                        (0, debug_1.assert)(paramInfo, 'paramInfo entry is undefined fork kwargs check');
+                        return (paramInfo.param.name === arg.name.value &&
+                            paramInfo.param.category === 0 /* Simple */);
+                    });
                     // Is this a parameter that can be interpreted as either a keyword or a positional?
                     // If so, we'll treat it as a keyword parameter in this case because it's being
                     // targeted by a keyword argument.
@@ -6570,7 +6630,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (0, debug_1.assert)(paramDetails.params[paramIndex], 'paramIndex params entry is undefined');
             const paramType = paramDetails.params[paramIndex].type;
             const paramName = paramDetails.params[paramIndex].param.name;
-            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            const isParamVariadic = paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
                 (0, types_1.isVariadicTypeVar)(paramType);
             if (argList[argIndex].argumentCategory === 1 /* UnpackedList */) {
                 let isArgCompatibleWithVariadic = false;
@@ -6631,7 +6691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     listElementType =
                         (_e = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                         /* isAsync */ false, argList[argIndex].valueExpression)) === null || _d === void 0 ? void 0 : _d.type) !== null && _e !== void 0 ? _e : types_1.UnknownType.create();
-                    if (paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    if (paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
                 }
@@ -6676,16 +6736,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     paramMap.has(paramName)) {
                     paramMap.get(paramName).argsReceived++;
                 }
-                if (advanceToNextArg ||
-                    paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+                if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                     argIndex++;
                 }
                 if (isVariadicTypeVarFullyMatched ||
-                    paramDetails.params[paramIndex].param.category !== 1 /* VarArgList */) {
+                    paramDetails.params[paramIndex].param.category !== 1 /* ArgsList */) {
                     paramIndex++;
                 }
             }
-            else if (paramDetails.params[paramIndex].param.category === 1 /* VarArgList */) {
+            else if (paramDetails.params[paramIndex].param.category === 1 /* ArgsList */) {
                 trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
                 if (paramSpecArgList) {
                     paramSpecArgList.push(argList[argIndex]);
@@ -6701,7 +6760,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         effectiveParamType = paramType.tupleTypeArguments[0].type;
                     }
                     paramCategory = (0, types_1.isVariadicTypeVar)(effectiveParamType)
-                        ? 1 /* VarArgList */
+                        ? 1 /* ArgsList */
                         : 0 /* Simple */;
                     if (remainingArgCount <= remainingParamCount) {
                         if (remainingArgCount < remainingParamCount) {
@@ -6758,7 +6817,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let skippedArgsParam = false;
         if (positionalOnlyLimitIndex >= 0 &&
             paramIndex < positionalOnlyLimitIndex &&
-            paramDetails.params[paramIndex].param.category === 1 /* VarArgList */ &&
+            paramIndex < paramDetails.params.length &&
+            paramDetails.params[paramIndex].param.category === 1 /* ArgsList */ &&
             !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].param.type)) {
             paramIndex++;
             skippedArgsParam = true;
@@ -6779,7 +6839,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // because it's permitted to pass zero arguments to *args.
                 argsRemainingCount--;
             }
-            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* VarArgList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
+            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* ArgsList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
             if (firstArgsParam >= paramIndex && firstArgsParam < positionalOnlyLimitIndex) {
                 // If there is another args parameter beyond the current param index,
                 // reduce the count by one because it's permitted to pass zero arguments
@@ -6841,7 +6901,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else if (paramDetails.kwargsIndex !== undefined) {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: {
@@ -6879,7 +6939,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         unpackedDictionaryArgType = types_1.AnyType.create();
                         if (typeResult.type.details.paramSpec) {
                             validateArgTypeParams.push({
-                                paramCategory: 2 /* VarArgDictionary */,
+                                paramCategory: 2 /* KwargsDict */,
                                 paramType: typeResult.type.details.paramSpec,
                                 requiresTypeVarMatching: false,
                                 argument: argList[argIndex],
@@ -6964,7 +7024,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             else {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
-                                    paramCategory: 2 /* VarArgDictionary */,
+                                    paramCategory: 2 /* KwargsDict */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
@@ -7008,7 +7068,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }
                             if ((0, types_1.isParamSpec)(argType) && argType.paramSpecAccess === 'args') {
                                 validateArgTypeParams.push({
-                                    paramCategory: 1 /* VarArgList */,
+                                    paramCategory: 1 /* ArgsList */,
                                     paramType: typeResult.type.details.paramSpec,
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
@@ -7057,7 +7117,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // (i.e. an arg starting with a "**"), we will assume that all parameters
             // are matched.
             if (!unpackedDictionaryArgType && !types_1.FunctionType.isDefaultParameterCheckDisabled(typeResult.type)) {
-                const unassignedParams = [...paramMap.keys()].filter((name) => {
+                const unassignedParams = Array.from(paramMap.keys()).filter((name) => {
                     const entry = paramMap.get(name);
                     return !entry || entry.argsReceived < entry.argsNeeded;
                 });
@@ -7111,6 +7171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // already been matched, see if the type of that *args parameter is a variadic
             // type variable. If so, we'll preprocess those arguments and combine them
             // into a tuple.
+            (0, debug_1.assert)(paramDetails.argsIndex === undefined || paramDetails.argsIndex < paramDetails.params.length, 'paramDetails.argsIndex params entry is invalid');
             if (paramDetails.argsIndex !== undefined &&
                 paramDetails.argsIndex >= 0 &&
                 paramDetails.params[paramDetails.argsIndex].param.hasDeclaredType &&
@@ -7157,7 +7218,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             /* isUnpackedTuple */ true));
                         }
                         const combinedArg = {
-                            paramCategory: 1 /* VarArgList */,
+                            paramCategory: 1 /* ArgsList */,
                             paramType,
                             requiresTypeVarMatching: true,
                             argument: {
@@ -7207,6 +7268,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
+        // Can we safely ignore the inference context (either because it's not provided
+        // or will have no effect)? If so, we can eliminate a bunch of extra work.
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
@@ -7236,6 +7299,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
         }
         if (effectiveExpectedType) {
+            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
             // Prepopulate the typeVarContext based on the specialized expected type if the
             // callee has a declared return type. This will allow us to more closely match
             // the expected type if possible.
@@ -7255,7 +7319,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes);
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
@@ -7271,6 +7335,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
             }
+            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7367,17 +7432,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
-                        // If we skipped a overload arg during the first pass,
-                        // add another pass to ensure that we handle all of the
-                        // type variables.
+                        // If we skipped an overload arg or a bare type var during the first pass,
+                        // add another pass to ensure that we handle all of the type variables.
                         if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
                             passCount++;
                         }
                     });
                 });
             }
-            // Lock the type var map so it cannot be modified and revalidate the
-            // arguments in a second pass.
+            // Lock the type var map so it cannot be modified when revalidating
+            // the arguments in a second pass.
             typeVarContext.lock();
         }
         let sawParamSpecArgs = false;
@@ -7465,21 +7529,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             type.details.typeVarScopeId === types_1.WildcardTypeVarScopeId) {
             eliminateUnsolvedInUnions = false;
         }
-        // In general, we want to replace in-scope TypeVars with Unknown
-        // if they were not solved. However, if the return type is a
-        // Callable, we'll leave the TypeVars unsolved because
-        // the call below to adjustCallableReturnType will "detach" these
-        // TypeVars from the scope of this function and "attach" them to
-        // the scope of the callable.
-        let unknownIfNotFound = !(0, types_1.isFunction)(returnType);
-        // We'll also leave TypeVars unsolved if the call is a recursive
+        // We'll leave TypeVars unsolved if the call is a recursive
         // call to a generic function.
-        const typeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
-            unknownIfNotFound = false;
-        }
+        const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
             useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
@@ -7532,6 +7587,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall: argumentErrors ? [] : [type],
         };
     }
+    // In general, all in-scope type variables left in a return type should be
+    // replaced with Unknown. However, if the return type is a callable that uses
+    // type vars that are found nowhere within the function's input parameters,
+    // we'll treat these as though they're scoped to the callable and leave them
+    // unsolved.
+    function getUnknownExemptTypeVarsForReturnType(functionType, returnType) {
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
+            const returnTypeScopeId = returnType.details.typeVarScopeId;
+            // If one or more type vars found within the return type are scoped to
+            // the functionType but don't appear anywhere else within the functionType's
+            // input parameters, rescope them to the return type callable so they are
+            // not replaced with Unknown.
+            if (returnTypeScopeId && functionType.details.typeVarScopeId) {
+                let typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgumentsRecursive)(returnType);
+                // Remove any type variables that appear in the function's input parameters.
+                functionType.details.parameters.forEach((param, index) => {
+                    if (param.hasDeclaredType) {
+                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgumentsRecursive)(param.type);
+                        typeVarsInReturnType = typeVarsInReturnType.filter((returnTypeVar) => !typeVarsInInputParam.some((inputTypeVar) => (0, types_1.isTypeSame)(returnTypeVar, inputTypeVar)));
+                    }
+                });
+                return typeVarsInReturnType;
+            }
+        }
+        return [];
+    }
     function adjustCallableReturnType(returnType) {
         // If the return type includes a generic Callable type, set the type var
         // scope to a wildcard to allow these type vars to be solved. This won't
@@ -7611,8 +7692,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (positionalIndexLimit < 0) {
             positionalIndexLimit = paramSpecParams.length;
         }
-        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
-        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
+        const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* ArgsList */);
+        const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* KwargsDict */);
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         let sawUnpackedListArgument = false;
         let sawUnpackedDictArgument = false;
@@ -7672,7 +7753,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             else if (arg.argumentCategory === 1 /* UnpackedList */) {
                 sawUnpackedListArgument = true;
                 // See if there is an *args parameter.
-                const argsParam = paramSpecParams.find((param) => param.category === 1 /* VarArgList */ && param.name);
+                const argsParam = paramSpecParams.find((param) => param.category === 1 /* ArgsList */ && param.name);
                 if (argsParam && paramMap.has(argsParam.name)) {
                     // TODO - validate args type
                     paramMap.delete(argsParam.name);
@@ -7682,7 +7763,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawUnpackedDictArgument = true;
                 (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
                 // See if there is an *kwargs parameter.
-                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* VarArgDictionary */);
+                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* KwargsDict */);
                 if (kwargsParam && paramMap.has(kwargsParam.name)) {
                     // TODO - validate kwargs type
                     paramMap.delete(kwargsParam.name);
@@ -7691,7 +7772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         // Report any missing parameters.
         if (!reportedArgError) {
-            let unassignedParams = [...paramMap.keys()];
+            let unassignedParams = Array.from(paramMap.keys());
             // Parameters that have defaults can be left unspecified.
             unassignedParams = unassignedParams.filter((name) => {
                 const paramInfo = paramMap.get(name);
@@ -7810,7 +7891,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
-        if (argParam.paramCategory === 2 /* VarArgDictionary */ && (0, types_1.isTypeVar)(argParam.paramType)) {
+        if (argParam.paramCategory === 2 /* KwargsDict */ && (0, types_1.isTypeVar)(argParam.paramType)) {
             argType = stripLiteralValue(argType);
         }
         // If there's a constraint filter, apply it to top-level type variables
@@ -8400,7 +8481,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else if (baseClass.literalValue !== undefined) {
             addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
         }
-        const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
+        let classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
+        classFlags |= 4096 /* Final */;
         const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
@@ -9183,28 +9265,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
+        // Handle the case where the expected type contains a ParamSpec.
+        if (expectedFunctionType === null || expectedFunctionType === void 0 ? void 0 : expectedFunctionType.details.paramSpec) {
+            functionType.details.paramSpec = expectedFunctionType.details.paramSpec;
+        }
         const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
-        const inferLambdaReturnType = () => {
+        // We need to set allowCacheRetention to false because we don't want to
+        // cache the type of the lambda return expression because it depends on
+        // the parameter types that we set above, and the speculative type cache
+        // doesn't know about that context.
+        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
-        };
-        // We need to set allowCacheRetention to false because we don't want to
-        // cache the type of the lambda return expression because it depends on
-        // the parameter types that we set above, and the speculative type cache
-        // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
-            inferLambdaReturnType();
-        }, 
-        /* allowCacheRetention */ false);
+        }, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType);
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
         return { type: functionType, isIncomplete };
@@ -9213,13 +9295,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         var _a;
         let isIncomplete = false;
         let typeErrors = false;
+        // If any of the "for" clauses are marked async or any of the "if" clauses
+        // or the final expression contain an "await" operator anywhere within
+        // the expression, it is treated as an async generator.
         let isAsync = node.forIfNodes.some((comp) => {
             return ((comp.nodeType === 33 /* ListComprehensionFor */ && comp.isAsync) ||
                 (comp.nodeType === 34 /* ListComprehensionIf */ &&
-                    comp.testExpression.nodeType === 6 /* Await */));
+                    ParseTreeUtils.containsAwaitNode(comp.testExpression)));
         });
         let type = types_1.UnknownType.create();
-        if (node.expression.nodeType === 6 /* Await */) {
+        if (ParseTreeUtils.containsAwaitNode(node.expression)) {
             isAsync = true;
         }
         let expectedElementType;
@@ -9459,12 +9544,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const paramName = `__p${index.toString()}`;
                     if ((0, types_1.isVariadicTypeVar)(entryType)) {
                         validateVariadicTypeVarIsUnpacked(entryType, entry.node);
-                        paramCategory = 1 /* VarArgList */;
+                        paramCategory = 1 /* ArgsList */;
                         noteSawUnpacked(entry);
                     }
                     else if (validateTypeArg(entry, { allowUnpackedTuples: true })) {
                         if ((0, types_1.isUnpackedClass)(entryType)) {
-                            paramCategory = 1 /* VarArgList */;
+                            paramCategory = 1 /* ArgsList */;
                             noteSawUnpacked(entry);
                         }
                     }
@@ -9764,7 +9849,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
     }
-    function createRequiredType(classType, errorNode, isRequired, typeArgs, flags) {
+    function createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
@@ -9772,7 +9857,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            addError(isRequired ? localize_1.Localizer.Diagnostic.requiredArgCount() : localize_1.Localizer.Diagnostic.notRequiredArgCount(), errorNode);
+            addError(classType.details.name === 'ReadOnly'
+                ? localize_1.Localizer.Diagnostic.readOnlyArgCount()
+                : classType.details.name === 'Required'
+                    ? localize_1.Localizer.Diagnostic.requiredArgCount()
+                    : localize_1.Localizer.Diagnostic.notRequiredArgCount(), errorNode);
             return { type: classType };
         }
         const typeArgType = typeArgs[0].type;
@@ -9791,17 +9880,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 1048576 /* AllowRequired */) !== 0) {
             isUsageLegal = true;
         }
-        // Nested Required/NotRequired are not allowed.
-        if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
-            isUsageLegal = false;
+        let isReadOnly = typeArgs[0].isReadOnly;
+        let isRequired = typeArgs[0].isRequired;
+        let isNotRequired = typeArgs[0].isNotRequired;
+        if (classType.details.name === 'ReadOnly') {
+            // Nested ReadOnly are not allowed.
+            if (typeArgs[0].isReadOnly) {
+                isUsageLegal = false;
+            }
+            isReadOnly = true;
+        }
+        else {
+            // Nested Required/NotRequired are not allowed.
+            if (typeArgs[0].isRequired || typeArgs[0].isNotRequired) {
+                isUsageLegal = false;
+            }
+            isRequired = classType.details.name === 'Required';
+            isNotRequired = classType.details.name === 'NotRequired';
         }
+        isRequired = classType.details.name === 'Required';
+        isNotRequired = classType.details.name === 'NotRequired';
         if (!isUsageLegal) {
-            addError(isRequired
-                ? localize_1.Localizer.Diagnostic.requiredNotInTypedDict()
-                : localize_1.Localizer.Diagnostic.notRequiredNotInTypedDict(), errorNode);
+            addError(classType.details.name === 'ReadOnly'
+                ? localize_1.Localizer.Diagnostic.readOnlyNotInTypedDict()
+                : classType.details.name === 'Required'
+                    ? localize_1.Localizer.Diagnostic.requiredNotInTypedDict()
+                    : localize_1.Localizer.Diagnostic.notRequiredNotInTypedDict(), errorNode);
             return { type: types_1.ClassType.cloneForSpecialization(classType, [(0, typeUtils_1.convertToInstance)(typeArgType)], !!typeArgs) };
         }
-        return { type: typeArgType, isRequired, isNotRequired: !isRequired };
+        return { type: typeArgType, isReadOnly, isRequired, isNotRequired };
     }
     function createUnpackType(classType, errorNode, typeArgs, flags) {
         // If no type arguments are provided, the resulting type
@@ -9888,6 +9995,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             type: types_1.TypeBase.cloneForAnnotated(typeArgs[0].type),
+            isReadOnly: typeArgs[0].isReadOnly,
             isRequired: typeArgs[0].isRequired,
             isNotRequired: typeArgs[0].isNotRequired,
         };
@@ -10166,7 +10274,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // methods that are abstract are overridden and shouldn't
                 // cause the TypedDict to be marked as abstract.
                 if ((0, types_1.isInstantiableClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
-                    baseClass.details.flags &= ~512 /* SupportsAbstractMethods */;
+                    baseClass.details.flags &= ~1024 /* SupportsAbstractMethods */;
                 }
             }
         }
@@ -10222,6 +10330,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             ['NoReturn', { alias: '', module: 'builtins' }],
             ['Never', { alias: '', module: 'builtins' }],
             ['LiteralString', { alias: '', module: 'builtins' }],
+            ['ReadOnly', { alias: '', module: 'builtins' }],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -10611,7 +10720,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     argType = types_1.UnknownType.create();
                 }
                 else {
-                    argType = getTypeOfExpression(arg.valueExpression, exprFlags).type;
+                    argType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(arg.valueExpression, exprFlags).type);
                 }
                 // In some stub files, classes are conditionally defined (e.g. based
                 // on platform type). We'll assume that the conditional logic is correct
@@ -10708,7 +10817,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // built-in protocol classes.
                     if (types_1.ClassType.supportsAbstractMethods(argType) ||
                         (types_1.ClassType.isProtocolClass(argType) && !types_1.ClassType.isBuiltIn(argType))) {
-                        classType.details.flags |= 512 /* SupportsAbstractMethods */;
+                        classType.details.flags |= 1024 /* SupportsAbstractMethods */;
                     }
                     if (types_1.ClassType.isPropertyClass(argType)) {
                         classType.details.flags |= 2048 /* PropertyClass */;
@@ -10760,16 +10869,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     metaclassNode = arg.valueExpression;
                 }
             }
-            else if (arg.name.value === 'total' && types_1.ClassType.isTypedDictClass(classType)) {
-                // The "total" parameter name applies only for TypedDict classes.
+            else if (types_1.ClassType.isTypedDictClass(classType) &&
+                (arg.name.value === 'total' || arg.name.value === 'readonly')) {
+                // The "total" and "readonly" parameters apply only for TypedDict classes.
                 // PEP 589 specifies that the parameter must be either True or False.
                 const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (constArgValue === undefined) {
-                    addError(localize_1.Localizer.Diagnostic.typedDictTotalParam(), arg.valueExpression);
+                    addError(localize_1.Localizer.Diagnostic.typedDictBoolParam().format({ name: arg.name.value }), arg.valueExpression);
                 }
-                else if (!constArgValue) {
+                else if (arg.name.value === 'total' && !constArgValue) {
                     classType.details.flags |= 256 /* CanOmitDictValues */;
                 }
+                else if (arg.name.value === 'readonly' && constArgValue) {
+                    classType.details.flags |= 512 /* DictValuesReadOnly */;
+                }
             }
             else {
                 // Collect arguments that will be passed to the `__init_subclass__`
@@ -10906,7 +11019,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         classType.details.flags |= 1048576 /* EnumClass */;
                     }
                     else if (types_1.ClassType.isBuiltIn(metaclassType, 'ABCMeta')) {
-                        classType.details.flags |= 512 /* SupportsAbstractMethods */;
+                        classType.details.flags |= 1024 /* SupportsAbstractMethods */;
                     }
                 }
             }
@@ -10981,7 +11094,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // This needs to be done after dataclass processing.
         if (classType.details.localSlotsNames) {
             let isLimitedToSlots = true;
-            const extendedSlotsNames = [...classType.details.localSlotsNames];
+            const extendedSlotsNames = Array.from(classType.details.localSlotsNames);
             classType.details.baseClasses.forEach((baseClass) => {
                 if ((0, types_1.isInstantiableClass)(baseClass)) {
                     if (!types_1.ClassType.isBuiltIn(baseClass, 'object') &&
@@ -11821,17 +11934,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             param.defaultValue.constType === 26 /* None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
             !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
-            type = (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
-        }
-        else if ((0, types_1.isTypeVar)(type) && param.defaultValue && type.scopeType === 1 /* Function */) {
-            // Handle the case where a default argument type is provided when the
-            // parameter is annotated with a "raw" function-scoped type variable, as in:
-            //   "def foo(value: T = 3)"
-            // In this case, we need to include the default value type in a union.
-            const defaultArgType = getTypeOfExpression(param.defaultValue, 1 /* ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(type)).type;
-            if (!(0, types_1.isAny)(defaultArgType)) {
-                type = (0, types_1.combineTypes)([type, defaultArgType]);
-            }
+            return (0, types_1.combineTypes)([type, types_1.NoneType.createInstance()]);
         }
         return type;
     }
@@ -11915,7 +12018,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             case 0 /* Simple */: {
                 return type;
             }
-            case 1 /* VarArgList */: {
+            case 1 /* ArgsList */: {
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
                 }
@@ -11928,7 +12031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return types_1.UnknownType.create();
             }
-            case 2 /* VarArgDictionary */: {
+            case 2 /* KwargsDict */: {
                 // Leave a ParamSpec alone.
                 if ((0, types_1.isTypeVar)(type) && type.paramSpecAccess) {
                     return type;
@@ -12886,9 +12989,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             getTypeOfAnnotation(annotationNode, {
                 isVariableAnnotation: ((_a = annotationNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 54 /* TypeAnnotation */,
                 allowUnpackedTuple: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 1 /* VarArgList */,
+                    annotationParent.category === 1 /* ArgsList */,
                 allowUnpackedTypedDict: annotationParent.nodeType === 41 /* Parameter */ &&
-                    annotationParent.category === 2 /* VarArgDictionary */,
+                    annotationParent.category === 2 /* KwargsDict */,
             });
             return;
         }
@@ -13364,8 +13467,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return { type: createUnpackType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Required':
-                case 'NotRequired': {
-                    return createRequiredType(classType, errorNode, aliasedName === 'Required', typeArgs, flags);
+                case 'NotRequired':
+                case 'ReadOnly': {
+                    return createRequiredOrReadOnlyType(classType, errorNode, typeArgs, flags);
                 }
                 case 'Self': {
                     return { type: createSelfType(classType, errorNode, typeArgs) };
@@ -13803,11 +13907,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types, under the assumption that we're performing speculative evaluations.
     // If speculativeNode is undefined, speculative mode is not used. This is
     // useful in cases where we conditionally want to use speculative mode.
-    function useSpeculativeMode(speculativeNode, callback, allowCacheRetention = true) {
+    function useSpeculativeMode(speculativeNode, callback, dependentType) {
         if (!speculativeNode) {
             return callback();
         }
-        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, allowCacheRetention);
+        speculativeTypeTracker.enterSpeculativeContext(speculativeNode, dependentType);
         try {
             const result = callback();
             speculativeTypeTracker.leaveSpeculativeContext();
@@ -16005,10 +16109,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* diag */ undefined, destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
                         filteredOverloads.push(overload);
                         if (destTypeVarContextClone) {
-                            destTypeVarSignatures.push(...destTypeVarContextClone.getSignatureContexts());
+                            (0, collectionUtils_1.appendArray)(destTypeVarSignatures, destTypeVarContextClone.getSignatureContexts());
                         }
                         if (srcTypeVarContextClone) {
-                            srcTypeVarSignatures.push(...srcTypeVarContextClone.getSignatureContexts());
+                            (0, collectionUtils_1.appendArray)(srcTypeVarSignatures, srcTypeVarContextClone.getSignatureContexts());
                         }
                     }
                 });
@@ -16562,7 +16666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const srcPositionalsToPack = srcDetails.params.slice(destDetails.argsIndex, srcLastToPackIndex - suffixLength);
         const srcTupleTypes = [];
         srcPositionalsToPack.forEach((entry) => {
-            if (entry.param.category === 1 /* VarArgList */) {
+            if (entry.param.category === 1 /* ArgsList */) {
                 if ((0, types_1.isUnpackedVariadicTypeVar)(entry.type)) {
                     srcTupleTypes.push({ type: entry.type, isUnbounded: false });
                 }
@@ -16594,7 +16698,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ...srcDetails.params.slice(0, destDetails.argsIndex),
                 {
                     param: {
-                        category: 1 /* VarArgList */,
+                        category: 1 /* ArgsList */,
                         name: '_arg_combined',
                         isNameSynthesized: true,
                         hasDeclaredType: true,
@@ -16606,9 +16710,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 },
                 ...srcDetails.params.slice(destDetails.argsIndex + srcPositionalsToPack.length, srcDetails.params.length),
             ];
-            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* VarArgList */);
+            const argsIndex = srcDetails.params.findIndex((param) => param.param.category === 1 /* ArgsList */);
             srcDetails.argsIndex = argsIndex >= 0 ? argsIndex : undefined;
-            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* VarArgDictionary */);
+            const kwargsIndex = srcDetails.params.findIndex((param) => param.param.category === 2 /* KwargsDict */);
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
             const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.source === parameterUtils_1.ParameterSource.KeywordOnly);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
@@ -16646,8 +16750,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (destParamName && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(destParamName) && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(srcParamName)) {
                 const isDestPositionalOnly = destParam.source === parameterUtils_1.ParameterSource.PositionOnly;
                 if (!isDestPositionalOnly &&
-                    destParam.param.category !== 1 /* VarArgList */ &&
-                    srcParam.param.category !== 1 /* VarArgList */ &&
+                    destParam.param.category !== 1 /* ArgsList */ &&
+                    srcParam.param.category !== 1 /* ArgsList */ &&
                     destParamName !== srcParamName) {
                     diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.functionParamName().format({
                         srcName: srcParamName,
@@ -16943,7 +17047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             matchedParamCount++;
                         }
                     }
-                    else if (!p.name && p.category === 0 /* Simple */ && remainingParams.length === 0) {
+                    else if ((0, types_1.isPositionOnlySeparator)(p) && remainingParams.length === 0) {
                         // Don't bother pushing a position-only separator if it
                         // is the first remaining param.
                     }
@@ -17272,7 +17376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     baseParam.category === 0 /* Simple */ &&
                     baseParam.name !== overrideParam.name) {
                     if (overrideParam.category === 0 /* Simple */) {
-                        if (enforceParamNames) {
+                        if (enforceParamNames && !baseParam.isNameSynthesized) {
                             if (overrideParamDetails.params[i].source === parameterUtils_1.ParameterSource.PositionOnly) {
                                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
                                     index: i + 1,
@@ -17292,11 +17396,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (i < overrideParamDetails.positionOnlyParamCount &&
                     i >= baseParamDetails.positionOnlyParamCount) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
-                        index: i + 1,
-                        baseName: baseParam.name || '*',
-                    }));
-                    canOverride = false;
+                    if (!baseParam.isNameSynthesized) {
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNamePositionOnly().format({
+                            index: i + 1,
+                            baseName: baseParam.name || '*',
+                        }));
+                        canOverride = false;
+                    }
                 }
                 else {
                     const baseParamType = baseParamDetails.params[i].type;
@@ -17407,6 +17513,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 canOverride = false;
             }
         }
+        // Verify that one or the other method doesn't contain a ParamSpec.
+        if (baseMethod.details.paramSpec && !overrideMethod.details.paramSpec) {
+            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.paramSpecMissingInOverride());
+            canOverride = false;
+        }
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
@@ -17783,7 +17894,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const textValue = node.strings[0].value;
         // Determine the offset within the file where the string
         // literal's contents begin.
-        const valueOffset = node.strings[0].start + node.strings[0].token.prefixLength + node.strings[0].token.quoteMarkLength;
+        let valueOffset = node.strings[0].start;
+        if (node.strings[0].nodeType === 49 /* String */) {
+            valueOffset += node.strings[0].token.prefixLength + node.strings[0].token.quoteMarkLength;
+        }
         const parseOptions = new parser_1.ParseOptions();
         parseOptions.isStubFile = fileInfo.isStubFile;
         parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
@@ -17859,7 +17973,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         validateOverloadedFunctionArguments,
         isAfterNodeReachable,
         isNodeReachable,
-        isAsymmetricDescriptorAssignment,
+        isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,