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

package/dist/analyzer/typeEvaluator.js

@@ -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);
@@ -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 {
@@ -2538,7 +2540,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 +3201,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,
@@ -3968,16 +3982,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);
                 }
@@ -5059,7 +5063,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 +5074,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 +5250,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);
@@ -6169,13 +6187,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, 
@@ -7215,18 +7239,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 +7370,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 +7478,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 +7595,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 +7658,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,
@@ -7672,7 +7709,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if (!reportedArgError) {
-            typeVarContext.applySourceContextTypeVars(srcTypeVarContext);
+            (0, typeUtils_1.applySourceContextTypeVarsToSignature)(typeVarContext, srcTypeVarContext);
         }
         return !reportedArgError;
     }
@@ -7683,14 +7720,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 +7756,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 +7807,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 +7838,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 +7867,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 +7931,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 +7987,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 +8062,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 +8117,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 +8143,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 +8158,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 +8170,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 +8194,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 +8221,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 +8236,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 +8251,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 +8382,30 @@ 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);
+        }
+        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(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 +8433,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 +8576,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 +8592,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 +8649,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 +8658,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 +8717,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 +8725,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 +8744,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 +8773,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 +8860,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 +8875,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 +8917,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 +8935,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 +9018,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 +9040,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 +9183,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;
@@ -9946,7 +10138,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);
@@ -10190,7 +10382,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 +10452,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) {
@@ -11005,7 +11205,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 +12030,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;
                 }
@@ -13448,8 +13648,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 {
@@ -16840,7 +17043,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 +17051,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 +17066,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 +17078,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 +17095,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 +17106,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 +17577,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));
@@ -17614,6 +17821,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,
@@ -17707,6 +17926,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         setTypeForNode,
         checkForCancellation,
         printControlFlowGraph,
+        printTypeVarContext,
     };
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
     return evaluatorInterface;