@zzzen/pyright-internal 1.2.0-dev.20230507 → 1.2.0-dev.20230521

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
@@ -446,7 +446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
-        var _a, _b;
+        var _a;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -646,6 +646,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
+        // If there was an expected type, make sure that the result type is compatible.
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
@@ -653,9 +654,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
-                // Use the "solve for scopes" of the associated typeVarContext if
-                // it is provided.
-                if (!assignType(inferenceContext.expectedType, typeResult.type, diag, new typeVarContext_1.TypeVarContext((_b = inferenceContext.typeVarContext) === null || _b === void 0 ? void 0 : _b.getSolveForScopes()))) {
+                if (!assignType(inferenceContext.expectedType, typeResult.type, diag)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -823,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)) {
@@ -1226,7 +1225,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: memberInfo.type,
                 classType: memberInfo.classType,
                 isIncomplete: !!memberInfo.isTypeIncomplete,
-                isAsymmetricDescriptor: memberInfo.isAsymmetricDescriptor,
+                isAsymmetricAccessor: memberInfo.isAsymmetricAccessor,
             };
         }
         return undefined;
@@ -1273,7 +1272,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.
@@ -1385,12 +1384,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const isObjectInit = !!methodType &&
                             (0, types_1.isFunction)(methodType) &&
                             methodType.details.fullName === 'builtins.object.__init__';
-                        const isSkipConstructor = !!methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.isSkipConstructorCheck(methodType);
                         const isDefaultParams = methodType && (0, types_1.isFunction)(methodType) && types_1.FunctionType.hasDefaultParameters(methodType);
                         // If there was no `__init__` or the only `__init__` that was found was from
                         // the `object` class or accepts only default parameters(* args, ** kwargs),
                         // see if we can find a better signature from the `__new__` method.
-                        if (!methodType || isObjectInit || isSkipConstructor || isDefaultParams) {
+                        if (!methodType || isObjectInit || isDefaultParams) {
                             const constructorType = getBoundMethod(subtype, '__new__', 
                             /* recursionCount */ undefined, 
                             /* treatConstructorAsClassMember */ true);
@@ -1534,8 +1532,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if ((0, types_1.isClassInstance)(declaredType)) {
                     const setterInfo = (0, typeUtils_1.lookUpClassMember)(declaredType, '__set__');
                     const setter = setterInfo ? getTypeOfMember(setterInfo) : undefined;
-                    if (setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
+                    if (setterInfo && setter && (0, types_1.isFunction)(setter) && setter.details.parameters.length >= 3) {
                         declaredType = setter.details.parameters[2].type;
+                        if ((0, types_1.isClass)(setterInfo.classType)) {
+                            const typeVarMap = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(setterInfo.classType);
+                            declaredType = (0, typeUtils_1.applySolvedTypeVars)(declaredType, typeVarMap);
+                        }
                         if ((0, types_1.isAnyOrUnknown)(declaredType)) {
                             return undefined;
                         }
@@ -2021,7 +2023,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 // Constrain the resulting type to match the declared type.
-                destType = narrowTypeBasedOnAssignment(declaredType, type);
+                destType = narrowTypeBasedOnAssignment(nameNode, declaredType, type);
             }
         }
         else {
@@ -2100,7 +2102,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 */);
@@ -2320,6 +2322,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, 
@@ -2538,7 +2543,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             // is a enum because the annotated type in an enum doesn't reflect
                             // the type of the symbol.
                             if (!(0, types_1.isClassInstance)(type) || !types_1.ClassType.isEnumClass(type)) {
-                                type = narrowTypeBasedOnAssignment(annotationType, type);
+                                type = narrowTypeBasedOnAssignment(target, annotationType, type);
                             }
                         }
                     }
@@ -3199,6 +3204,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             container: typeAliasNode.name.value,
                         }), node);
                     }
+                    else {
+                        // If this is a TypeAliasType call, the recursiveTypeParameters will already
+                        // be populated, and we need to verify that the type parameter is in the
+                        // list of allowed type parameters.
+                        const allowedTypeParams = leftType.details.recursiveTypeParameters;
+                        if (allowedTypeParams) {
+                            if (!allowedTypeParams.some((param) => param.details.name === type.details.name)) {
+                                // Return the original type.
+                                return { type, isRescoped: false, foundInterveningClass: false };
+                            }
+                        }
+                    }
                     return {
                         type: types_1.TypeVarType.cloneForScopeId(type, leftType.details.recursiveTypeAliasScopeId, leftType.details.recursiveTypeAliasName, 2 /* TypeAlias */),
                         isRescoped: false,
@@ -3281,7 +3298,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
@@ -3340,7 +3357,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),
@@ -3365,8 +3382,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 {
@@ -3383,8 +3400,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;
@@ -3584,7 +3601,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;
@@ -3719,7 +3736,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
@@ -3731,11 +3748,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,
                 };
             }
         }
@@ -3748,7 +3765,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);
@@ -3933,7 +3950,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) {
@@ -3968,16 +3985,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If this function is an instance member (e.g. a lambda that was
                 // assigned to an instance variable), don't perform any binding.
                 if (!isAccessedThroughObject || (memberInfo && !memberInfo.isInstanceMember)) {
-                    // Skip binding if the class appears to be a metaclass (i.e. a subclass of
-                    // `type`) because the first parameter of instance methods in a metaclass
-                    // are not `self` instances.
-                    const isMetaclass = !isAccessedThroughObject &&
-                        (0, types_1.isClass)(baseTypeClass) &&
-                        (flags & 16 /* TreatConstructorAsClassMethod */) === 0 &&
-                        baseTypeClass.details.mro.some((mroType) => (0, types_1.isClass)(mroType) && types_1.ClassType.isBuiltIn(mroType, 'type'));
-                    if (isMetaclass) {
-                        return concreteSubtype;
-                    }
                     return bindFunctionToClassOrObject(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(baseTypeClass) : baseTypeClass, concreteSubtype, memberInfo && (0, types_1.isInstantiableClass)(memberInfo.classType) ? memberInfo.classType : undefined, errorNode, 
                     /* recursionCount */ undefined, treatConstructorAsClassMember, bindToType);
                 }
@@ -4047,7 +4054,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!isTypeValid) {
             return undefined;
         }
-        return { type, isAsymmetricDescriptor };
+        return { type, isAsymmetricAccessor };
     }
     function isAsymmetricDescriptorClass(classType) {
         var _a;
@@ -4081,6 +4088,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;
@@ -4135,7 +4174,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,
+                    };
                 }
             }
         }
@@ -4471,6 +4517,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;
@@ -4577,6 +4624,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)) {
@@ -4608,7 +4658,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
@@ -5059,7 +5109,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if (!matchingSubtype) {
                     const subtypeResult = useSpeculativeMode(node, () => {
-                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                        return getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                     });
                     if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                         matchingSubtype = subtype;
@@ -5070,7 +5120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -5246,6 +5296,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else {
+                // Check for an attempt to invoke an abstract static or class method.
+                if ((0, types_1.isFunction)(baseTypeResult.type) &&
+                    baseTypeResult.type.boundToType &&
+                    (0, types_1.isInstantiableClass)(baseTypeResult.type.boundToType) &&
+                    !baseTypeResult.type.boundToType.includeSubclasses) {
+                    if (types_1.FunctionType.isAbstractMethod(baseTypeResult.type)) {
+                        if (types_1.FunctionType.isStaticMethod(baseTypeResult.type) ||
+                            types_1.FunctionType.isClassMethod(baseTypeResult.type)) {
+                            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.abstractMethodInvocation().format({
+                                method: baseTypeResult.type.details.name,
+                            }), node.leftExpression);
+                        }
+                    }
+                }
                 const callResult = validateCallArguments(node, argList, baseTypeResult, 
                 /* typeVarContext */ undefined, 
                 /* skipUnknownArgCheck */ false, inferenceContext);
@@ -6059,7 +6123,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;
                     }
@@ -6105,7 +6169,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;
                     }
@@ -6169,13 +6233,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 return types_1.AnyType.create();
                             }
                             if (className === 'TypeVar') {
-                                return createTypeVarType(errorNode, argList);
+                                return createTypeVarType(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'TypeVarTuple') {
-                                return createTypeVarTupleType(errorNode, argList);
+                                return createTypeVarTupleType(errorNode, expandedSubtype, argList);
                             }
                             if (className === 'ParamSpec') {
-                                return createParamSpecType(errorNode, argList);
+                                return createParamSpecType(errorNode, expandedSubtype, argList);
+                            }
+                            if (className === 'TypeAliasType') {
+                                const newTypeAlias = createTypeAliasType(errorNode, argList);
+                                if (newTypeAlias) {
+                                    return newTypeAlias;
+                                }
                             }
                             if (className === 'NamedTuple') {
                                 return (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
@@ -6241,7 +6311,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;
                         }
@@ -6284,7 +6354,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;
                             }
@@ -6329,7 +6399,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;
                     }
@@ -7033,7 +7103,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;
                 });
@@ -7215,18 +7285,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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.
-            // If the return type is not the same as the expected type but is
-            // assignable to the expected type, determine which type arguments
-            // are needed to match the expected type.
-            if ((0, types_1.isClassInstance)(effectiveReturnType) &&
-                (0, types_1.isClassInstance)(effectiveExpectedType) &&
-                !types_1.ClassType.isSameGenericClass(effectiveReturnType, effectiveExpectedType)) {
-                const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
-                const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
-                /* typeArguments */ undefined, 
-                /* isTypeArgumentExplicit */ false);
-                effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
+            // Determine which type arguments are needed to match the expected type.
+            if ((0, types_1.isClassInstance)(effectiveReturnType)) {
+                // If the return type is a class and the expected type is a union that contains
+                // that class, see if we can eliminate the other subtypes in the union.
+                if ((0, types_1.isUnion)(effectiveExpectedType)) {
+                    const filteredType = (0, typeUtils_1.mapSubtypes)(effectiveExpectedType, (subtype) => {
+                        return (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(effectiveReturnType, subtype)
+                            ? subtype
+                            : undefined;
+                    });
+                    if ((0, types_1.isClassInstance)(filteredType)) {
+                        effectiveExpectedType = filteredType;
+                    }
+                }
+                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));
+                    const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
+                    /* typeArguments */ undefined, 
+                    /* isTypeArgumentExplicit */ false);
+                    effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext);
+                }
             }
             else if ((0, types_1.isFunction)(effectiveReturnType)) {
                 // If the return type is a callable and the expected type is a union that
@@ -7336,7 +7416,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // If we skipped a overload arg during the first pass,
                         // add another pass to ensure that we handle all of the
                         // type variables.
-                        if (i === 0 && argResult.skippedOverloadArg) {
+                        if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
                             passCount++;
                         }
                     });
@@ -7444,11 +7524,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (typeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope))) {
             unknownIfNotFound = false;
         }
-        let specializedReturnType = (0, typeUtils_1.addConditionToType)((0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
+        let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
             useUnknownOverDefault: skipUnknownArgCheck,
             eliminateUnsolvedInUnions,
-        }), typeCondition);
+            applyInScopePlaceholders: true,
+        });
+        specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
         // If the final return type is an unpacked tuple, turn it into a normal (unpacked) tuple.
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
@@ -7559,6 +7641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecNotBound().format({ type: printType(paramSpec) }), ((_a = argList[0]) === null || _a === void 0 ? void 0 : _a.valueExpression) || errorNode);
             return false;
         }
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         const srcTypeVarContext = new typeVarContext_1.TypeVarContext(paramSpecType.details.typeVarScopeId);
         let reportedArgError = false;
         // Build a map of all named parameters.
@@ -7621,7 +7704,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramType) {
                     const argResult = validateArgType({
                         paramCategory: 0 /* Simple */,
-                        paramType,
+                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes),
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
@@ -7654,7 +7737,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);
@@ -7672,7 +7755,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!reportedArgError) {
-            typeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+            (0, typeUtils_1.applySourceContextTypeVarsToSignature)(typeVarContext, srcTypeVarContext);
         }
         return !reportedArgError;
     }
@@ -7683,14 +7766,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete);
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
+        let skippedBareTypeVarExpectedType = false;
         if (argParam.argument.valueExpression) {
             let expectedType;
-            if (!options.skipBareTypeVarExpectedType ||
-                !(0, types_1.isTypeVar)(argParam.paramType) ||
-                argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
-                expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
-                    useNarrowBoundOnly: !!options.useNarrowBoundOnly,
-                });
+            const isBareTypeVarExpectedType = (0, types_1.isTypeVar)(argParam.paramType) && argParam.paramType.scopeId === (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId);
+            if (!options.skipBareTypeVarExpectedType || !isBareTypeVarExpectedType) {
+                expectedType = argParam.paramType;
+                // If the parameter type is a function with a ParamSpec, don't apply
+                // the solved TypeVars if the typeVarContext has more than one signature.
+                // This will expand the ParamSpec into an overload, which will cause problems.
+                const skipApplySolvedTypeVars = (0, types_1.isFunction)(argParam.paramType) &&
+                    !!argParam.paramType.details.paramSpec &&
+                    typeVarContext.getSignatureContexts().length > 1;
+                if (!skipApplySolvedTypeVars) {
+                    expectedType = (0, typeUtils_1.applySolvedTypeVars)(expectedType, typeVarContext, {
+                        useNarrowBoundOnly: !!options.useNarrowBoundOnly,
+                    });
+                }
+            }
+            else {
+                skippedBareTypeVarExpectedType = true;
             }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
@@ -7707,14 +7802,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, typeVarContext, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
                 argType = exprTypeResult.type;
+                // If the type includes multiple instances of a generic function
+                // signature, force the type arguments for the duplicates to have
+                // unique names.
+                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
                 if (exprTypeResult.typeErrors) {
                     isCompatible = false;
                 }
+                else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+                    // Assign the argument type back to the expected type to assign
+                    // values to any in-scope placeholder type variables.
+                    const typeVarContextClone = typeVarContext.clone();
+                    if (assignType(expectedType, argType, /* diag */ undefined, typeVarContextClone)) {
+                        typeVarContext.copyFromClone(typeVarContextClone);
+                    }
+                    else {
+                        isCompatible = false;
+                    }
+                }
                 expectedTypeDiag = exprTypeResult.expectedTypeDiagAddendum;
             }
             if (argParam.argument && argParam.argument.name && !isSpeculativeModeInUse(argParam.errorNode)) {
@@ -7743,10 +7853,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        // If the type includes multiple instances of a generic function
-        // signature, force the type arguments for the duplicates to have
-        // unique names.
-        argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
         // 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.
@@ -7778,14 +7884,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // an overloaded callback protocol.
         if (options.skipOverloadArg) {
             if ((0, types_1.isOverloadedFunction)(argType)) {
-                return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                return {
+                    isCompatible,
+                    argType,
+                    isTypeIncomplete,
+                    skippedOverloadArg: true,
+                    skippedBareTypeVarExpectedType,
+                    condition,
+                };
             }
             const concreteParamType = makeTopLevelTypeVarsConcrete(argParam.paramType);
             if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
                 if ((0, types_1.isInstantiableClass)(argType)) {
                     const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
                     if (constructor && (0, types_1.isOverloadedFunction)(constructor)) {
-                        return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                        return {
+                            isCompatible,
+                            argType,
+                            isTypeIncomplete,
+                            skippedOverloadArg: true,
+                            skippedBareTypeVarExpectedType,
+                            condition,
+                        };
                     }
                 }
                 if ((0, types_1.isClassInstance)(argType)) {
@@ -7793,7 +7913,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (callMember) {
                         const memberType = getTypeOfMember(callMember);
                         if ((0, types_1.isOverloadedFunction)(memberType)) {
-                            return { isCompatible, argType, isTypeIncomplete, skippedOverloadArg: true, condition };
+                            return {
+                                isCompatible,
+                                argType,
+                                isTypeIncomplete,
+                                skippedOverloadArg: true,
+                                skippedBareTypeVarExpectedType,
+                                condition,
+                            };
                         }
                     }
                 }
@@ -7850,7 +7977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), argParam.errorNode, (_a = diag.getEffectiveTextRange()) !== null && _a !== void 0 ? _a : argParam.errorNode);
             }
-            return { isCompatible: false, argType, isTypeIncomplete, condition };
+            return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
         if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
@@ -7906,9 +8033,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        return { isCompatible, argType, isTypeIncomplete, condition };
+        return { isCompatible, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
     }
-    function createTypeVarType(errorNode, argList) {
+    function createTypeVarType(errorNode, classType, argList) {
         var _a, _b, _c, _d, _e, _f, _g;
         let typeVarName = '';
         let firstConstraintArg;
@@ -7981,8 +8108,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (paramName === 'default') {
                     defaultValueNode = argList[i].valueExpression;
-                    const argType = (_d = (_c = argList[i].typeResult) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : getTypeOfExpressionExpectingType(argList[i].valueExpression).type;
+                    const argType = (_d = (_c = argList[i].typeResult) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : getTypeOfExpressionExpectingType(defaultValueNode, {
+                        allowTypeVarsWithoutScopeId: true,
+                    }).type;
                     typeVar.details.defaultType = (0, typeUtils_1.convertToInstance)(argType);
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), defaultValueNode);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.typeVarUnknownParam().format({ name: paramName }), ((_e = argList[i].node) === null || _e === void 0 ? void 0 : _e.name) || argList[i].valueExpression || errorNode);
@@ -8028,7 +8163,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeVar;
     }
-    function createTypeVarTupleType(errorNode, argList) {
+    function createTypeVarTupleType(errorNode, classType, argList) {
         var _a, _b;
         let typeVarName = '';
         if (argList.length === 0) {
@@ -8054,6 +8189,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (expr) {
                         typeVar.details.defaultType = getTypeVarTupleDefaultType(expr);
                     }
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.typeVarTupleUnknownParam().format({ name: ((_a = argList[i].name) === null || _a === void 0 ? void 0 : _a.value) || '?' }), ((_b = argList[i].node) === null || _b === void 0 ? void 0 : _b.name) || argList[i].valueExpression || errorNode);
@@ -8063,7 +8204,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeVar;
     }
     function getTypeVarTupleDefaultType(node) {
-        const argType = getTypeOfExpressionExpectingType(node, { allowUnpackedTuple: true }).type;
+        const argType = getTypeOfExpressionExpectingType(node, {
+            allowUnpackedTuple: true,
+            allowTypeVarsWithoutScopeId: true,
+        }).type;
         const isUnpackedTuple = (0, types_1.isClass)(argType) && (0, typeUtils_1.isTupleClass)(argType) && argType.isUnpacked;
         const isUnpackedTypeVarTuple = (0, types_1.isUnpackedVariadicTypeVar)(argType);
         if (!isUnpackedTuple && !isUnpackedTypeVarTuple) {
@@ -8072,7 +8216,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return (0, typeUtils_1.convertToInstance)(argType);
     }
-    function createParamSpecType(errorNode, argList) {
+    function createParamSpecType(errorNode, classType, argList) {
         if (argList.length === 0) {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), errorNode);
             return undefined;
@@ -8096,6 +8240,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (expr) {
                         paramSpec.details.defaultType = getParamSpecDefaultType(expr);
                     }
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    if (!fileInfo.isStubFile &&
+                        fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_13 &&
+                        classType.details.moduleName !== 'typing_extensions') {
+                        addError(localize_1.Localizer.Diagnostic.typeVarDefaultIllegal(), expr);
+                    }
                 }
                 else {
                     addError(localize_1.Localizer.Diagnostic.paramSpecUnknownParam().format({ name: paramName }), paramNameNode || argList[i].valueExpression || errorNode);
@@ -8117,7 +8267,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (node.nodeType === 31 /* List */) {
             node.entries.forEach((paramExpr, index) => {
-                const typeResult = getTypeOfExpressionExpectingType(paramExpr);
+                const typeResult = getTypeOfExpressionExpectingType(paramExpr, { allowTypeVarsWithoutScopeId: true });
                 types_1.FunctionType.addParameter(functionType, {
                     category: 0 /* Simple */,
                     name: `__p${index}`,
@@ -8132,7 +8282,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return functionType;
         }
         else {
-            const typeResult = getTypeOfExpressionExpectingType(node, { allowParamSpec: true });
+            const typeResult = getTypeOfExpressionExpectingType(node, {
+                allowParamSpec: true,
+                allowTypeVarsWithoutScopeId: true,
+            });
             if (typeResult.typeErrors) {
                 return undefined;
             }
@@ -8144,6 +8297,91 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.paramSpecDefaultNotTuple(), node);
         return undefined;
     }
+    // Handles a call to TypeAliasType(). This special form allows a caller to programmatically
+    // create a type alias as defined in PEP 695. If one or more of the arguments is incorrect,
+    // it returns undefined so the normal constructor evaluation can be performed (and type errors
+    // emitted).
+    function createTypeAliasType(errorNode, argList) {
+        if (errorNode.nodeType !== 9 /* Call */ || !errorNode.parent || argList.length < 2) {
+            return undefined;
+        }
+        if (errorNode.parent.nodeType !== 3 /* Assignment */ ||
+            errorNode.parent.rightExpression !== errorNode ||
+            errorNode.parent.leftExpression.nodeType !== 38 /* Name */) {
+            addError(localize_1.Localizer.Diagnostic.typeAliasTypeMustBeAssigned(), errorNode);
+            return undefined;
+        }
+        const nameNode = errorNode.parent.leftExpression;
+        const firstArg = argList[0];
+        if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* StringList */) {
+            const typeAliasName = firstArg.valueExpression.strings.map((s) => s.value).join('');
+            if (typeAliasName !== nameNode.value) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameMismatch(), firstArg.valueExpression);
+            }
+        }
+        else {
+            addError(localize_1.Localizer.Diagnostic.typeAliasTypeNameArg(), firstArg.valueExpression || errorNode);
+            return undefined;
+        }
+        let valueExpr;
+        let typeParamsExpr;
+        // Parse the remaining parameters.
+        for (let i = 1; i < argList.length; i++) {
+            const paramNameNode = argList[i].name;
+            const paramName = paramNameNode ? paramNameNode.value : undefined;
+            if (paramName) {
+                if (paramName === 'type_params' && !typeParamsExpr) {
+                    typeParamsExpr = argList[i].valueExpression;
+                }
+                else if (paramName === 'value' && !valueExpr) {
+                    valueExpr = argList[i].valueExpression;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else if (i === 1) {
+                valueExpr = argList[i].valueExpression;
+            }
+            else {
+                return undefined;
+            }
+        }
+        // The value expression is not optional, so bail if it's not present.
+        if (!valueExpr) {
+            return undefined;
+        }
+        let typeParameters;
+        if (typeParamsExpr) {
+            if (typeParamsExpr.nodeType !== 52 /* Tuple */) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                return undefined;
+            }
+            typeParameters = [];
+            let isTypeParamListValid = true;
+            typeParamsExpr.expressions.map((expr) => {
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingType */).type;
+                if ((0, types_1.isTypeVar)(entryType)) {
+                    if (entryType.scopeId) {
+                        isTypeParamListValid = false;
+                    }
+                    else {
+                        entryType = types_1.TypeVarType.cloneForScopeId(entryType, ParseTreeUtils.getScopeIdForNode(nameNode), nameNode.value, 2 /* TypeAlias */);
+                    }
+                    typeParameters.push(entryType);
+                }
+                else {
+                    isTypeParamListValid = false;
+                }
+            });
+            if (!isTypeParamListValid) {
+                addError(localize_1.Localizer.Diagnostic.typeAliasTypeParamInvalid(), typeParamsExpr);
+                return undefined;
+            }
+        }
+        return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
+        /* typeParamNodes */ undefined, () => typeParameters);
+    }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* Constant */) {
             if (node.constType === 15 /* False */) {
@@ -8190,19 +8428,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.newTypeBadName(), (_a = argList[0].node) !== null && _a !== void 0 ? _a : errorNode);
             return undefined;
         }
-        const baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
-        if ((0, types_1.isInstantiableClass)(baseClass)) {
-            if (types_1.ClassType.isProtocolClass(baseClass)) {
-                addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
-            }
-            else if (baseClass.literalValue !== undefined) {
-                addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+        let baseClass = getTypeOfArgumentExpectingType(argList[1]).type;
+        let isBaseClassAny = false;
+        if ((0, types_1.isAnyOrUnknown)(baseClass)) {
+            if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                baseClass = types_1.ClassType.cloneAsInstantiable(objectType);
             }
-            const classFlags = baseClass.details.flags & ~(1 /* BuiltInClass */ | 2 /* SpecialBuiltIn */);
-            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(baseClass);
-            (0, typeUtils_1.computeMroLinearization)(classType);
+            isBaseClassAny = true;
+        }
+        if (!(0, types_1.isInstantiableClass)(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
+            return undefined;
+        }
+        if (types_1.ClassType.isProtocolClass(baseClass)) {
+            addError(localize_1.Localizer.Diagnostic.newTypeProtocolClass(), argList[1].node || errorNode);
+        }
+        else if (baseClass.literalValue !== undefined) {
+            addError(localize_1.Localizer.Diagnostic.newTypeLiteral(), argList[1].node || errorNode);
+        }
+        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);
+        (0, typeUtils_1.computeMroLinearization)(classType);
+        if (!isBaseClassAny) {
             // Synthesize an __init__ method that accepts only the specified type.
             const initType = types_1.FunctionType.createSynthesizedInstance('__init__');
             types_1.FunctionType.addParameter(initType, {
@@ -8230,12 +8480,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.addDefaultParameters(newType);
             newType.details.declaredReturnType = types_1.ClassType.cloneAsInstance(classType);
             classType.details.fields.set('__new__', symbol_1.Symbol.createWithType(4 /* ClassMember */, newType));
-            return classType;
         }
-        if (!(0, types_1.isAnyOrUnknown)(baseClass)) {
-            addError(localize_1.Localizer.Diagnostic.newTypeNotAClass(), argList[1].node || errorNode);
-        }
-        return undefined;
+        return classType;
     }
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createType(errorNode, argList) {
@@ -8377,7 +8623,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    return getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -8393,7 +8639,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let expectedTypeDiagAddendum = undefined;
         if (effectiveExpectedType) {
             expectedTypeDiagAddendum = new diagnostic_1.DiagnosticAddendum();
-            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), expectedTypeDiagAddendum);
+            const result = getTypeOfDictionaryWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType), expectedTypeDiagAddendum);
             if (result) {
                 return result;
             }
@@ -8450,7 +8696,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const expectedValueType = specializedDict.typeArguments[1];
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum, inferenceContext)) {
+        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
             isIncomplete = true;
         }
         // Dict and MutableMapping types have invariant value types, so they
@@ -8459,9 +8705,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
                 types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
-        const specializedKeyType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedKeyType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), keyTypes.map((result) => result.type), 
+        const specializedKeyType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedKeyType), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
-        const specializedValueType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), valueTypes.map((result) => result.type), !isValueTypeInvariant);
+        const specializedValueType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedValueType), valueTypes.map((result) => result.type), !isValueTypeInvariant);
         if (!specializedKeyType || !specializedValueType) {
             return undefined;
         }
@@ -8518,7 +8764,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum, inferenceContext) {
+    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
@@ -8526,7 +8772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined), inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -8545,12 +8791,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedTypedDictEntries.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -8574,7 +8820,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -8661,7 +8907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     return;
                 }
                 const subtypeResult = useSpeculativeMode(node, () => {
-                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                    return getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(subtype));
                 });
                 if (subtypeResult && assignType(subtype, subtypeResult.type)) {
                     // If this is the first result we're seeing or it's the first result
@@ -8676,7 +8922,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            const result = getTypeOfListOrSetWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -8718,7 +8964,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             else {
                 entryTypeResult = getTypeOfExpression(entry, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
             }
             entryTypes.push(entryTypeResult.type);
             if (entryTypeResult.isIncomplete) {
@@ -8736,7 +8982,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         const isTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             types_1.ClassType.isBuiltIn(inferenceContext.expectedType, builtInClassName);
-        const specializedEntryType = inferTypeArgFromExpectedType((0, typeUtils_1.makeInferenceContext)(expectedEntryType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext), entryTypes, !isTypeInvariant);
+        const specializedEntryType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedEntryType), entryTypes, !isTypeInvariant);
         if (!specializedEntryType) {
             return { type: types_1.UnknownType.create(), isIncomplete, typeErrors: true, expectedTypeDiagAddendum };
         }
@@ -8819,17 +9065,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message + diag.getString(), entry);
         }
     }
-    function inferTypeArgFromExpectedType(inferenceContext, entryTypes, isNarrowable) {
-        var _a;
+    function inferTypeArgFromExpectedEntryType(inferenceContext, entryTypes, isNarrowable) {
         // If the expected type is Any, the resulting type becomes Any.
         if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
             return inferenceContext.expectedType;
         }
-        const typeVarContext = (_a = inferenceContext.typeVarContext) === null || _a === void 0 ? void 0 : _a.clone();
+        const typeVarContext = new typeVarContext_1.TypeVarContext();
+        const expectedType = inferenceContext.expectedType;
         let isCompatible = true;
         entryTypes.forEach((entryType) => {
-            if (isCompatible &&
-                !assignType(inferenceContext.expectedType, entryType, /* diag */ undefined, typeVarContext)) {
+            if (isCompatible && !assignType(expectedType, entryType, /* diag */ undefined, typeVarContext)) {
                 isCompatible = false;
             }
         });
@@ -8842,10 +9087,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ? combinedTypes
                 : stripLiteralValue(combinedTypes);
         }
-        if (typeVarContext) {
-            return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext);
-        }
-        return inferenceContext.expectedType;
+        return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext, { applyInScopePlaceholders: true });
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -8988,18 +9230,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        let expectedReturnType = expectedFunctionType
+        const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
-        if (expectedReturnType && (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext)) {
-            expectedReturnType = (0, typeUtils_1.applySolvedTypeVars)(expectedReturnType, inferenceContext.typeVarContext);
-        }
         // 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 = () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
-            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.typeVarContext));
+            /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -9572,7 +9811,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.
@@ -9580,7 +9819,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;
@@ -9599,17 +9842,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
@@ -9696,6 +9957,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,
         };
@@ -9946,7 +10208,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 names: boundTypeVars.map((t) => `${t.details.name}`).join(', '),
             }), errorNode);
         }
-        return types_1.TypeBase.cloneForTypeAlias(type, name.value, `${fileInfo.moduleName}.${name.value}`, typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
+        return types_1.TypeBase.cloneForTypeAlias(type, name.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.value), typeAliasScopeId, typeParameters.length > 0 ? typeParameters : undefined);
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -9974,7 +10236,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 */;
                 }
             }
         }
@@ -10030,6 +10292,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) {
@@ -10190,7 +10453,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (assignType(declaredType, srcType)) {
                         // Narrow the resulting type if possible.
                         if (!(0, types_1.isAnyOrUnknown)(srcType)) {
-                            srcType = narrowTypeBasedOnAssignment(declaredType, srcType);
+                            srcType = narrowTypeBasedOnAssignment(node, declaredType, srcType);
                         }
                     }
                 }
@@ -10260,52 +10523,60 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // variables since they use normal variable assignment syntax.
     function getTypeOfTypeAlias(node) {
         var _a;
-        const cachedType = readTypeCache(node.name, 0 /* None */);
+        return getTypeOfTypeAliasCommon(node, node.name, node.expression, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters, () => {
+            let typeParameters = [];
+            if (node.typeParameters) {
+                typeParameters = evaluateTypeParameterList(node.typeParameters);
+            }
+            return typeParameters;
+        });
+    }
+    // This function is common to the handling of "type" statements and explicit
+    // calls to the TypeAliasType constructor.
+    function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, typeParamNodes, getTypeParamCallback) {
+        const cachedType = readTypeCache(nameNode, 0 /* None */);
         if (cachedType) {
             return cachedType;
         }
         // Synthesize a type variable that represents the type alias while we're
         // evaluating it. This allows us to handle recursive definitions.
-        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${node.name.value}`);
+        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.value}`);
         typeAliasTypeVar.details.isSynthesized = true;
-        typeAliasTypeVar.details.recursiveTypeAliasName = node.name.value;
-        const scopeId = ParseTreeUtils.getScopeIdForNode(node.name);
+        typeAliasTypeVar.details.recursiveTypeAliasName = nameNode.value;
+        const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
         typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
         typeAliasTypeVar.scopeId = scopeId;
         // Write the type to the type cache. It will be replaced below.
-        writeTypeCache(node.name, { type: typeAliasTypeVar }, /* flags */ undefined);
+        writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
-        const scope = ScopeUtils.getScopeForNode(node);
-        const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(node.name.value);
-        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(node);
+        const scope = ScopeUtils.getScopeForNode(declNode);
+        const typeAliasSymbol = scope === null || scope === void 0 ? void 0 : scope.lookUpSymbolRecursive(nameNode.value);
+        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(declNode);
         if (typeAliasDecl && typeAliasSymbol) {
             setSymbolResolutionPartialType(typeAliasSymbol.symbol, typeAliasDecl, typeAliasTypeVar);
         }
-        let typeParameters = [];
-        if (node.typeParameters) {
-            typeParameters = evaluateTypeParameterList(node.typeParameters);
-            typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
-        }
-        if (!isLegalTypeAliasExpressionForm(node.expression)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), node.expression);
+        const typeParameters = getTypeParamCallback();
+        typeAliasTypeVar.details.recursiveTypeParameters = typeParameters;
+        if (!isLegalTypeAliasExpressionForm(valueNode)) {
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIllegalExpressionForm(), valueNode);
         }
-        const aliasTypeResult = getTypeOfExpressionExpectingType(node.expression);
+        const aliasTypeResult = getTypeOfExpressionExpectingType(valueNode, { allowForwardReference: true });
         let isIncomplete = false;
         let aliasType = aliasTypeResult.type;
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, node.name, node.expression, typeParameters, (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.parameters);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, valueNode, typeParameters, typeParamNodes);
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
-                name: node.name.value,
-            }), node.expression);
+            addDiagnostic(AnalyzerNodeInfo.getFileInfo(valueNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveDirect().format({
+                name: nameNode.value,
+            }), valueNode);
             aliasType = types_1.UnknownType.create();
         }
         // Set the resulting type to the boundType of the original type alias
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
-        writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
+        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
@@ -10411,7 +10682,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
@@ -10508,7 +10779,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 */;
@@ -10560,16 +10831,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__`
@@ -10706,7 +10981,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 */;
                     }
                 }
             }
@@ -10781,7 +11056,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') &&
@@ -11005,7 +11280,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     decoratorCallType.details.builtInName === 'dataclass_transform') {
                     originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                 }
-                else if (decoratorCallType.details.name === 'deprecated') {
+                else if (decoratorCallType.details.builtInName === 'deprecated') {
                     originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
                     return inputClassType;
                 }
@@ -11830,7 +12105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
                     return inputFunctionType;
                 }
-                if (decoratorCallType.details.name === 'deprecated') {
+                if (decoratorCallType.details.builtInName === 'deprecated') {
                     undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
                     return inputFunctionType;
                 }
@@ -13164,8 +13439,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) };
@@ -13448,8 +13724,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfExpressionExpectingType(node, options) {
         let flags = 128 /* ExpectingType */ | 8 /* EvaluateStringLiteralAsType */ | 131072 /* DisallowClassVar */;
+        if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
+            flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
+        }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        if (fileInfo.isStubFile) {
+        if (fileInfo.isStubFile || (options === null || options === void 0 ? void 0 : options.allowForwardReference)) {
             flags |= 4 /* AllowForwardReferences */;
         }
         else {
@@ -15802,10 +16081,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());
                         }
                     }
                 });
@@ -16840,7 +17119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Apply any solved source TypeVars to the dest TypeVar solutions. This
         // allows for higher-order functions to accept generic callbacks.
-        destTypeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+        (0, typeUtils_1.applySourceContextTypeVars)(destTypeVarContext, srcTypeVarContext);
         return canAssign;
     }
     // If the declaredType contains type arguments that are "Any" and
@@ -16848,7 +17127,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // replace that type argument in the assigned type. This function assumes
     // that the caller has already verified that the assignedType is assignable
     // to the declaredType.
-    function replaceTypeArgsWithAny(declaredType, assignedType, recursionCount = 0) {
+    function replaceTypeArgsWithAny(node, declaredType, assignedType, recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return undefined;
         }
@@ -16863,7 +17142,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
             (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
-            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, []);
+            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node));
             let replacedTypeArg = false;
             const newTypeArgs = assignedType.typeArguments.map((typeArg, index) => {
                 const typeParam = assignedType.details.typeParameters[index];
@@ -16875,7 +17154,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     else if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
                         // Recursively replace Any in the type argument.
-                        const recursiveReplacement = replaceTypeArgsWithAny(expectedTypeArgType, typeArg, recursionCount);
+                        const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
                         if (recursiveReplacement) {
                             replacedTypeArg = true;
                             return recursiveReplacement;
@@ -16892,7 +17171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     // When a value is assigned to a variable with a declared type,
     // we may be able to narrow the type based on the assignment.
-    function narrowTypeBasedOnAssignment(declaredType, assignedType) {
+    function narrowTypeBasedOnAssignment(node, declaredType, assignedType) {
         const narrowedType = (0, typeUtils_1.mapSubtypes)(assignedType, (assignedSubtype) => {
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
                 // We can't narrow "Any".
@@ -16903,13 +17182,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     // If the source is generic and has unspecified type arguments,
                     // see if we can determine then based on the declared type.
                     if ((0, types_1.isInstantiableClass)(declaredSubtype) && (0, types_1.isInstantiableClass)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(declaredSubtype, assignedSubtype);
+                        const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
                         if (result) {
                             assignedSubtype = result;
                         }
                     }
                     else if ((0, types_1.isClassInstance)(declaredSubtype) && (0, types_1.isClassInstance)(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
+                        const result = replaceTypeArgsWithAny(node, types_1.ClassType.cloneAsInstantiable(declaredSubtype), types_1.ClassType.cloneAsInstantiable(assignedSubtype));
                         if (result) {
                             assignedSubtype = types_1.ClassType.cloneAsInstance(result);
                         }
@@ -17374,6 +17653,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return types_1.FunctionType.clone(memberType, /* stripFirstParam */ true);
             }
             if (types_1.FunctionType.isInstanceMethod(memberType)) {
+                // If the baseType is a metaclass, don't specialize the function.
+                if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
+                    return memberType;
+                }
                 const baseObj = (0, types_1.isClassInstance)(baseType)
                     ? baseType
                     : types_1.ClassType.cloneAsInstance((0, typeUtils_1.specializeClassType)(baseType));
@@ -17576,7 +17859,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;
@@ -17614,6 +17900,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
+    function printTypeVarContext(typeVarContext) {
+        const contexts = typeVarContext.getSignatureContexts();
+        contexts.forEach((context, index) => {
+            if (contexts.length > 1) {
+                console.log(`Signature context ${index + 1}:`);
+            }
+            context.getTypeVars().forEach((typeVarEntry) => {
+                const type = context.getTypeVarType(typeVarEntry.typeVar);
+                console.log(`  ${typeVarEntry.typeVar.details.name}: ${type ? printType(type) : '<none>'}`);
+            });
+        });
+    }
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -17640,7 +17938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         validateOverloadedFunctionArguments,
         isAfterNodeReachable,
         isNodeReachable,
-        isAsymmetricDescriptorAssignment,
+        isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
         suppressDiagnostics,
         getDeclarationsForStringNode,
         getDeclarationsForNameNode,
@@ -17707,6 +18005,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         setTypeForNode,
         checkForCancellation,
         printControlFlowGraph,
+        printTypeVarContext,
     };
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
     return evaluatorInterface;