@zzzen/pyright-internal 1.2.0-dev.20240915 → 1.2.0-dev.20240929

package/dist/analyzer/typeEvaluator.js

@@ -209,6 +209,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let intClass;
     let strClass;
     let dictClass;
+    let moduleTypeClass;
     let typedDictPrivateClass;
     let supportsKeysAndGetItemClass;
     let mappingClass;
@@ -390,7 +391,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // context, logging any errors in the process. This may require the
     // type of surrounding statements to be evaluated.
     function getType(node) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         initializePrefetchedTypes(node);
         let type = (_a = evaluateTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
@@ -405,8 +406,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (classTypeResult) {
                     inferVarianceForClass(classTypeResult.classType);
                     const typeParam = classTypeResult.classType.shared.typeParams.find((param) => (0, types_1.isTypeSame)(param, typeVarType, { ignoreTypeFlags: true }));
-                    if (typeParam) {
-                        type = types_1.TypeBase.isInstance(type) ? types_1.TypeVarType.cloneAsInstance(typeParam) : typeParam;
+                    if ((typeParam === null || typeParam === void 0 ? void 0 : typeParam.priv.computedVariance) !== undefined) {
+                        type = types_1.TypeVarType.cloneWithComputedVariance(type, typeParam.priv.computedVariance);
+                    }
+                }
+            }
+            else if (((_c = typeParamListNode === null || typeParamListNode === void 0 ? void 0 : typeParamListNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 77 /* ParseNodeType.TypeAlias */) {
+                const typeAliasType = getTypeOfTypeAlias(typeParamListNode.parent);
+                const typeParamIndex = typeParamListNode.d.params.findIndex((param) => param.d.name === node);
+                if (typeParamIndex >= 0) {
+                    inferVarianceForTypeAlias(typeAliasType);
+                    const typeAliasInfo = (_d = typeAliasType.props) === null || _d === void 0 ? void 0 : _d.typeAliasInfo;
+                    if (typeAliasInfo === null || typeAliasInfo === void 0 ? void 0 : typeAliasInfo.shared.computedVariance) {
+                        const computedVariance = typeAliasInfo.shared.computedVariance[typeParamIndex];
+                        type = types_1.TypeVarType.cloneWithComputedVariance(type, computedVariance);
                     }
                 }
             }
@@ -490,6 +503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             intClass = getBuiltInType(node, 'int');
             strClass = getBuiltInType(node, 'str');
             dictClass = getBuiltInType(node, 'dict');
+            moduleTypeClass = getTypingType(node, 'ModuleType');
             typedDictPrivateClass = getTypingType(node, '_TypedDict');
             awaitableClass = getTypingType(node, 'Awaitable');
             mappingClass = getTypingType(node, 'Mapping');
@@ -992,7 +1006,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
         updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
-        if (node.d.annotation) {
+        if (node.d.annotation && (flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
             return getTypeOfExpression(node.d.annotation, updatedFlags);
         }
         if (node.d.strings.length === 1) {
@@ -1724,6 +1738,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getDeclaredTypeForExpression(expression, usage) {
         var _a, _b;
         let symbol;
+        let selfType;
         let classOrObjectBase;
         let memberAccessClass;
         let bindFunction = true;
@@ -1756,11 +1771,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return getDeclaredTypeForExpression(expression.d.valueExpr, usage);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */).type);
+                const baseType = getTypeOfExpression(expression.d.leftExpr, 2 /* EvalFlags.MemberAccessBaseDefaults */).type;
+                const baseTypeConcrete = makeTopLevelTypeVarsConcrete(baseType);
                 let classMemberInfo;
-                if ((0, types_1.isClassInstance)(baseType)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.d.member.d.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
-                    classOrObjectBase = baseType;
+                if ((0, types_1.isClassInstance)(baseTypeConcrete)) {
+                    classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseTypeConcrete, expression.d.member.d.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                    classOrObjectBase = baseTypeConcrete;
                     memberAccessClass = classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.classType;
                     // If this is an instance member (e.g. a dataclass field), don't
                     // bind it to the object if it's a function.
@@ -1769,11 +1785,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     useDescriptorSetterType = true;
                 }
-                else if ((0, types_1.isInstantiableClass)(baseType)) {
-                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseType, expression.d.member.d.value, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
-                    classOrObjectBase = baseType;
+                else if ((0, types_1.isInstantiableClass)(baseTypeConcrete)) {
+                    classMemberInfo = (0, typeUtils_1.lookUpClassMember)(baseTypeConcrete, expression.d.member.d.value, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                    classOrObjectBase = baseTypeConcrete;
                     memberAccessClass = classMemberInfo === null || classMemberInfo === void 0 ? void 0 : classMemberInfo.classType;
                 }
+                if ((0, types_1.isTypeVar)(baseType)) {
+                    selfType = baseType;
+                }
                 if (classMemberInfo) {
                     symbol = classMemberInfo.symbol;
                 }
@@ -1814,11 +1833,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (classOrObjectBase) {
                     if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
-                        declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType());
+                        declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType(), selfType);
                     }
                     if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloaded)(declaredType)) {
                         if (bindFunction) {
-                            declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType);
+                            declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType, 
+                            /* memberClass */ undefined, 
+                            /* treatConstructorAsClassMethod */ undefined, selfType);
                         }
                     }
                 }
@@ -3236,17 +3257,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // If the value is a special form (like a TypeVar or `Any`) and is being
     // evaluated in a value expression context, convert it from its special
-    // meaning to its runtime value.
-    function convertSpecialFormToRuntimeValue(type, flags) {
+    // meaning to its runtime value. If convertModule is true, a module is
+    // converted to an instance of types.ModuleType.
+    function convertSpecialFormToRuntimeValue(type, flags, convertModule = false) {
         var _a, _b, _c, _d;
         const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
         if ((flags & exemptFlags) !== 0) {
             return type;
         }
+        if (convertModule && (0, types_1.isModule)(type) && moduleTypeClass && (0, types_1.isInstantiableClass)(moduleTypeClass)) {
+            return types_1.ClassType.cloneAsInstance(moduleTypeClass);
+        }
         // Isinstance treats traditional (non-PEP 695) type aliases that are unions
         // as tuples of classes rather than unions.
         if ((flags & 536870912 /* EvalFlags.IsinstanceArg */) !== 0) {
-            if ((0, types_1.isUnion)(type) && ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) && !type.props.typeAliasInfo.isPep695Syntax) {
+            if ((0, types_1.isUnion)(type) && ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) && !type.props.typeAliasInfo.shared.isPep695Syntax) {
                 return type;
             }
         }
@@ -3594,7 +3619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                     return {
-                        type: types_1.TypeVarType.cloneForScopeId(type, leftType.shared.recursiveAlias.scopeId, leftType.shared.recursiveAlias.name, 2 /* TypeVarScopeType.TypeAlias */),
+                        type: types_1.TypeVarType.cloneForScopeId(type, leftType.shared.recursiveAlias.typeVarScopeId, leftType.shared.recursiveAlias.name, 2 /* TypeVarScopeType.TypeAlias */),
                         scopeNode,
                         foundInterveningClass: false,
                     };
@@ -4270,8 +4295,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             accessMethodName = '__delete__';
         }
+        const subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
-        /* usage */ undefined, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
+        /* usage */ undefined, subDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
         if (!methodTypeResult || methodTypeResult.typeErrors) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType) && usage.method !== 'get') {
@@ -4287,6 +4313,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const methodClassType = methodTypeResult.classType;
         let methodType = methodTypeResult.type;
         if (methodTypeResult.typeErrors || !methodClassType) {
+            if (diag && subDiag) {
+                diag.addAddendum(subDiag);
+            }
             return { type: types_1.UnknownType.create(), typeErrors: true };
         }
         if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloaded)(methodType)) {
@@ -4804,13 +4833,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return type;
         }
         // Is this a generic type alias that needs specializing?
-        if (!aliasInfo.typeParams || aliasInfo.typeParams.length === 0 || aliasInfo.typeArgs) {
+        if (!aliasInfo.shared.typeParams || aliasInfo.shared.typeParams.length === 0 || aliasInfo.typeArgs) {
             return type;
         }
         let reportDiag = false;
         const defaultTypeArgs = [];
         const constraints = new constraintTracker_1.ConstraintTracker();
-        aliasInfo.typeParams.forEach((param) => {
+        aliasInfo.shared.typeParams.forEach((param) => {
             if (!param.shared.isDefaultExplicit) {
                 reportDiag = true;
             }
@@ -4818,7 +4847,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (param.shared.isDefaultExplicit || (0, types_1.isParamSpec)(param)) {
                 defaultType = solveAndApplyConstraints(param, constraints, {
                     replaceUnsolved: {
-                        scopeIds: [aliasInfo.typeVarScopeId],
+                        scopeIds: [aliasInfo.shared.typeVarScopeId],
                         tupleClassType: getTupleClassType(),
                     },
                 });
@@ -4835,12 +4864,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         if (reportDiag && errorNode) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
-                name: aliasInfo.name,
+                name: aliasInfo.shared.name,
             }), errorNode);
         }
         type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(type, constraints, {
             replaceUnsolved: {
-                scopeIds: [aliasInfo.typeVarScopeId],
+                scopeIds: [aliasInfo.shared.typeVarScopeId],
                 tupleClassType: getTupleClassType(),
             },
         }), { ...aliasInfo, typeArgs: defaultTypeArgs });
@@ -4856,7 +4885,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             aliasInfo = (_d = (_c = baseType.props.typeForm) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.typeAliasInfo;
             aliasBaseType = (0, typeUtils_1.convertToInstantiable)(baseType.props.typeForm);
         }
-        if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeParams) || (aliasInfo.typeParams.length === 0 && aliasInfo.typeArgs)) {
+        if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.shared.typeParams) || (aliasInfo.shared.typeParams.length === 0 && aliasInfo.typeArgs)) {
             return undefined;
         }
         // If this is not instantiable, then the index expression isn't a specialization.
@@ -4867,7 +4896,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (aliasInfo.typeArgs) {
             return undefined;
         }
-        const typeParams = aliasInfo.typeParams;
+        inferVarianceForTypeAlias(baseType);
+        const typeParams = aliasInfo.shared.typeParams;
         let typeArgs = adjustTypeArgsForTypeVarTuple(getTypeArgs(node, flags), typeParams, node);
         let reportedError = false;
         // PEP 612 says that if the class has only one type parameter consisting
@@ -4975,7 +5005,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (param.shared.isDefaultExplicit) {
                     typeArgType = solveAndApplyConstraints(param, constraints, {
                         replaceUnsolved: {
-                            scopeIds: [aliasInfo.typeVarScopeId],
+                            scopeIds: [aliasInfo.shared.typeVarScopeId],
                             tupleClassType: getTupleClassType(),
                         },
                     });
@@ -5012,7 +5042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const solutionSet = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
         const aliasTypeArgs = [];
-        (_f = aliasInfo.typeParams) === null || _f === void 0 ? void 0 : _f.forEach((typeParam) => {
+        (_f = aliasInfo.shared.typeParams) === null || _f === void 0 ? void 0 : _f.forEach((typeParam) => {
             let typeVarType = solutionSet.getType(typeParam);
             // Fill in any unsolved type arguments with unknown.
             if (!typeVarType) {
@@ -5051,7 +5081,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeAliasType') &&
             ((_b = baseTypeResult.type.props) === null || _b === void 0 ? void 0 : _b.typeForm)) {
             const typeAliasInfo = (_c = baseTypeResult.type.props.typeForm.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo;
-            if (typeAliasInfo && typeAliasInfo.typeParams) {
+            if (typeAliasInfo && typeAliasInfo.shared.typeParams) {
                 const origTypeAlias = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.convertToInstantiable)(baseTypeResult.type.props.typeForm), { ...typeAliasInfo, typeArgs: undefined });
                 const typeFormType = createSpecializedTypeAlias(node, origTypeAlias, flags);
                 if (typeFormType) {
@@ -5064,14 +5094,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
             const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, {
-                name: baseTypeResult.type.shared.recursiveAlias.name,
-                fullName: '',
-                moduleName: '',
-                fileUri: uri_1.Uri.empty(),
-                typeVarScopeId: baseTypeResult.type.shared.recursiveAlias.scopeId,
-                isPep695Syntax: !!baseTypeResult.type.shared.recursiveAlias.isPep695Syntax,
-                typeParams: baseTypeResult.type.shared.recursiveAlias.typeParams,
-                usageVariance: undefined,
+                shared: baseTypeResult.type.shared.recursiveAlias,
                 typeArgs: typeArgTypes,
             });
             return { type };
@@ -5239,31 +5262,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a;
         const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
         // If this isn't a generic type alias, there's nothing to do.
-        if (!aliasInfo || !aliasInfo.typeParams) {
+        if (!aliasInfo || !aliasInfo.shared.typeParams) {
             return undefined;
         }
-        // Is the usage variance info already cached?
-        if (aliasInfo.usageVariance) {
-            return aliasInfo.usageVariance;
+        // Is the computed variance info already cached?
+        if (aliasInfo.shared.computedVariance) {
+            return aliasInfo.shared.computedVariance;
         }
-        const typeParams = aliasInfo.typeParams;
+        const typeParams = aliasInfo.shared.typeParams;
         // Start with all of the usage variances unknown.
         const usageVariances = typeParams.map(() => 1 /* Variance.Unknown */);
         // Prepopulate the cached value for the type alias to handle
         // recursive type aliases.
-        aliasInfo.usageVariance = usageVariances;
+        aliasInfo.shared.computedVariance = usageVariances;
         // Traverse the type alias type definition and adjust the usage
         // variances accordingly.
-        updateUsageVariancesRecursive(type, typeParams, usageVariances);
+        updateUsageVariancesRecursive(type, typeParams, usageVariances, 3 /* Variance.Covariant */);
         return usageVariances;
     }
     // Looks at uses of the type parameters within the type and adjusts the
     // variances accordingly. For example, if the type is `Mapping[T1, T2]`,
     // then T1 will be set to invariant and T2 will be set to covariant.
-    function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, recursionCount = 0) {
+    function updateUsageVariancesRecursive(type, typeAliasTypeParams, usageVariances, varianceContext, recursionCount = 0) {
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return;
         }
+        const transformedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(type);
+        // If this is a recursive type alias, use a lower recursion limit.
+        if (transformedType !== type) {
+            if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+                return;
+            }
+        }
         recursionCount++;
         // Define a helper function that performs the actual usage variant update.
         function updateUsageVarianceForType(type, variance) {
@@ -5273,20 +5303,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     usageVariances[typeParamIndex] = (0, typeUtils_1.combineVariances)(usageVariances[typeParamIndex], variance);
                 }
                 else {
-                    updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, recursionCount);
+                    updateUsageVariancesRecursive(subtype, typeAliasTypeParams, usageVariances, variance, recursionCount);
                 }
             });
         }
-        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+        (0, typeUtils_1.doForEachSubtype)(transformedType, (subtype) => {
             if (subtype.category === 4 /* TypeCategory.Function */) {
-                if (subtype.priv.specializedTypes) {
-                    subtype.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                        updateUsageVarianceForType(paramType, 4 /* Variance.Contravariant */);
-                    });
-                    const returnType = subtype.priv.specializedTypes.returnType;
-                    if (returnType) {
-                        updateUsageVarianceForType(returnType, 3 /* Variance.Covariant */);
-                    }
+                subtype.shared.parameters.forEach((param, index) => {
+                    const paramType = types_1.FunctionType.getParamType(subtype, index);
+                    updateUsageVarianceForType(paramType, (0, typeUtils_1.invertVariance)(varianceContext));
+                });
+                const returnType = types_1.FunctionType.getEffectiveReturnType(subtype);
+                if (returnType) {
+                    updateUsageVarianceForType(returnType, varianceContext);
                 }
             }
             else if (subtype.category === 6 /* TypeCategory.Class */) {
@@ -5299,7 +5328,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     subtype.priv.typeArgs.forEach((typeArg, classParamIndex) => {
                         var _a;
                         if ((0, typeUtils_1.isTupleClass)(subtype)) {
-                            updateUsageVarianceForType(typeArg, 3 /* Variance.Covariant */);
+                            updateUsageVarianceForType(typeArg, varianceContext);
                         }
                         else if (classParamIndex < subtype.shared.typeParams.length) {
                             const classTypeParam = subtype.shared.typeParams[classParamIndex];
@@ -5309,7 +5338,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 });
                             }
                             else {
-                                updateUsageVarianceForType(typeArg, (_a = classTypeParam.priv.computedVariance) !== null && _a !== void 0 ? _a : classTypeParam.shared.declaredVariance);
+                                const effectiveVariance = (_a = classTypeParam.priv.computedVariance) !== null && _a !== void 0 ? _a : classTypeParam.shared.declaredVariance;
+                                updateUsageVarianceForType(typeArg, varianceContext === 4 /* Variance.Contravariant */
+                                    ? (0, typeUtils_1.invertVariance)(effectiveVariance)
+                                    : effectiveVariance);
                             }
                         }
                     });
@@ -5786,7 +5818,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 entryTypes.push({ type: types_1.UnknownType.create(/* isIncomplete */ true), isUnbounded: false });
             }
             else {
-                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */);
+                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */, 
+                /* convertModule */ true);
                 entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
                 entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
             }
@@ -6403,7 +6436,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 // Clone the constraints so we don't modify the original.
                 const effectiveConstraints = (_a = constraints === null || constraints === void 0 ? void 0 : constraints.clone()) !== null && _a !== void 0 ? _a : new constraintTracker_1.ConstraintTracker();
-                effectiveConstraints.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(speculativeNode, () => {
@@ -6515,7 +6547,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // And run through the first expanded argument list one more time to
         // populate the type cache.
         const finalConstraints = constraints !== null && constraints !== void 0 ? constraints : matchedOverloads[0].constraints;
-        finalConstraints.unlock();
         const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalConstraints, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
@@ -6689,7 +6720,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             const effectiveConstraints = constraints !== null && constraints !== void 0 ? constraints : new constraintTracker_1.ConstraintTracker();
-            effectiveConstraints.unlock();
             return validateArgTypesWithContext(errorNode, bestMatch, effectiveConstraints, skipUnknownArgCheck, inferenceContext);
         }
         // If there is only one possible arg/param match among the overloads,
@@ -7083,7 +7113,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // The one-parameter form of "type" returns the class
                 // for the specified object.
                 if (expandedCallType.shared.name === 'type' && argList.length === 1) {
-                    const argType = getTypeOfArg(argList[0], /* inferenceContext */ undefined).type;
+                    const argTypeResult = getTypeOfArg(argList[0], /* inferenceContext */ undefined);
+                    const argType = argTypeResult.type;
                     const returnType = (0, typeUtils_1.mapSubtypes)(argType, (subtype) => {
                         if ((0, types_1.isNever)(subtype)) {
                             return subtype;
@@ -7100,7 +7131,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             types_1.UnknownType.create(),
                         ]);
                     });
-                    return { returnType };
+                    return { returnType, isTypeIncomplete: argTypeResult.isIncomplete };
                 }
                 if (argList.length >= 2) {
                     // The two-parameter form of a call to a metaclass returns a new class
@@ -7364,11 +7395,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         paramDetails.params.forEach((paramInfo) => {
             (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
             const param = paramInfo.param;
-            if (param.name && param.category === 0 /* ParamCategory.Simple */) {
+            if (param.name && param.category === 0 /* ParamCategory.Simple */ && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
                 paramMap.set(param.name, {
                     argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType ? 1 : 0,
                     argsReceived: 0,
-                    isPositionalOnly: paramInfo.kind === parameterUtils_1.ParamKind.Positional,
                 });
             }
         });
@@ -7680,19 +7710,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else {
-                const paramName = paramDetails.params[paramIndex].param.name;
+                const paramInfo = paramDetails.params[paramIndex];
+                const paramName = paramInfo.param.name;
                 validateArgTypeParams.push({
-                    paramCategory: paramDetails.params[paramIndex].param.category,
+                    paramCategory: paramInfo.param.category,
                     paramType,
                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                     argument: argList[argIndex],
                     errorNode: argList[argIndex].valueExpression || errorNode,
                     paramName,
-                    isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramDetails.params[paramIndex].param),
+                    isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramInfo.param),
                 });
-                trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
+                trySetActive(argList[argIndex], paramInfo.param);
                 // Note that the parameter has received an argument.
-                if (paramName && paramMap.has(paramName)) {
+                if (paramName && paramMap.has(paramName) && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
                     paramMap.get(paramName).argsReceived++;
                 }
                 argIndex++;
@@ -7770,7 +7801,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         tdEntries.knownItems.forEach((entry, name) => {
                             var _a, _b;
                             const paramEntry = paramMap.get(name);
-                            if (paramEntry && !paramEntry.isPositionalOnly) {
+                            if (paramEntry) {
                                 if (paramEntry.argsReceived > 0) {
                                     diag.addMessage(localize_1.LocMessage.paramAlreadyAssigned().format({ name }));
                                 }
@@ -7809,7 +7840,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 paramMap.set(name, {
                                     argsNeeded: 1,
                                     argsReceived: 1,
-                                    isPositionalOnly: false,
                                 });
                             }
                             else {
@@ -7928,7 +7958,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (paramName) {
                         const paramNameValue = paramName.d.value;
                         const paramEntry = paramMap.get(paramNameValue);
-                        if (paramEntry && !paramEntry.isPositionalOnly) {
+                        if (paramEntry) {
                             if (paramEntry.argsReceived > 0) {
                                 if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramAlreadyAssigned().format({ name: paramNameValue }), paramName);
@@ -7937,7 +7967,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                             else {
                                 paramEntry.argsReceived++;
-                                const paramInfoIndex = paramDetails.params.findIndex((paramInfo) => paramInfo.param.name === paramNameValue);
+                                const paramInfoIndex = paramDetails.params.findIndex((paramInfo) => paramInfo.param.name === paramNameValue &&
+                                    paramInfo.kind !== parameterUtils_1.ParamKind.Positional);
                                 (0, debug_1.assert)(paramInfoIndex >= 0);
                                 const paramType = paramDetails.params[paramInfoIndex].type;
                                 validateArgTypeParams.push({
@@ -7975,7 +8006,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 paramMap.set(paramNameValue, {
                                     argsNeeded: 1,
                                     argsReceived: 1,
-                                    isPositionalOnly: false,
                                 });
                                 (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], 'paramDetails.kwargsIndex params entry is undefined');
                             }
@@ -8089,7 +8119,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const param = paramInfo.param;
                     if (param.category === 0 /* ParamCategory.Simple */ && param.name) {
                         const entry = paramMap.get(param.name);
-                        if (entry.argsNeeded === 0 && entry.argsReceived === 0) {
+                        if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0) {
                             const defaultArgType = paramInfo.defaultType;
                             if (defaultArgType &&
                                 !(0, typeUtils_1.isEllipsisType)(defaultArgType) &&
@@ -8391,9 +8421,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     });
                 });
             }
-            // Lock the type var map so it cannot be modified when revalidating
-            // the arguments in a second pass.
-            constraints.lock();
         }
         let sawParamSpecArgs = false;
         let sawParamSpecKwargs = false;
@@ -9697,8 +9724,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeErrors = true;
         }
         // Strip any literal values and TypeForm types.
-        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags)));
-        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags)));
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, /* convertModule */ true)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, /* convertModule */ true)));
         keyType = keyTypes.length > 0 ? (0, types_1.combineTypes)(keyTypes) : fallbackType;
         // If the value type differs and we're not using "strict inference mode",
         // we need to back off because we can't properly represent the mappings
@@ -10049,7 +10076,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
             }
-            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags));
+            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, /* convertModule */ true));
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -11433,7 +11460,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function transformTypeForTypeAlias(type, name, errorNode, isPep695Syntax, isPep695TypeVarType, typeParams, typeParamNodes) {
+    function transformTypeForTypeAlias(type, errorNode, typeAliasPlaceholder, isPep695TypeVarType, typeParamNodes) {
         var _a;
         if (!types_1.TypeBase.isInstantiable(type)) {
             return type;
@@ -11443,6 +11470,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             return type;
         }
+        const sharedInfo = typeAliasPlaceholder.shared.recursiveAlias;
+        (0, debug_1.assert)(sharedInfo !== undefined);
+        let typeParams = sharedInfo.typeParams;
         if (!typeParams) {
             // Determine if there are any generic type parameters associated
             // with this type alias.
@@ -11467,10 +11497,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithDefaultFollowsVariadic().format({
                     typeVarName: typeParams[typeVarWithDefaultIndex].shared.name,
                     variadicName: typeParams[firstTypeVarTupleIndex].shared.name,
-                }), typeParamNodes ? typeParamNodes[typeVarWithDefaultIndex].d.name : name);
+                }), typeParamNodes ? typeParamNodes[typeVarWithDefaultIndex].d.name : errorNode);
             }
         }
-        const typeAliasScopeId = ParseTreeUtils.getScopeIdForNode(name);
         // Validate the default types for all type parameters.
         typeParams.forEach((typeParam, index) => {
             var _a;
@@ -11479,7 +11508,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (typeParamNodes && index < typeParamNodes.length) {
                 bestErrorNode = (_a = typeParamNodes[index].d.defaultExpr) !== null && _a !== void 0 ? _a : typeParamNodes[index].d.name;
             }
-            validateTypeParamDefault(bestErrorNode, typeParam, typeParams.slice(0, index), typeAliasScopeId);
+            validateTypeParamDefault(bestErrorNode, typeParam, typeParams.slice(0, index), sharedInfo.typeVarScopeId);
         });
         // Verify that we have at most one TypeVarTuple.
         const variadics = typeParams.filter((param) => (0, types_1.isTypeVarTuple)(param));
@@ -11488,29 +11517,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 names: variadics.map((v) => `"${v.shared.name}"`).join(', '),
             }), errorNode);
         }
-        if (!isPep695Syntax && !isPep695TypeVarType) {
-            const boundTypeVars = typeParams.filter((typeVar) => typeVar.priv.scopeId !== typeAliasScopeId && typeVar.priv.scopeType === 0 /* TypeVarScopeType.Class */);
+        if (!sharedInfo.isPep695Syntax && !isPep695TypeVarType) {
+            const boundTypeVars = typeParams.filter((typeVar) => typeVar.priv.scopeId !== sharedInfo.typeVarScopeId &&
+                typeVar.priv.scopeType === 0 /* TypeVarScopeType.Class */);
             if (boundTypeVars.length > 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeAliasBoundTypeVar().format({
                     names: boundTypeVars.map((t) => `${t.shared.name}`).join(', '),
                 }), errorNode);
             }
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
+        sharedInfo.typeParams = typeParams.length > 0 ? typeParams : undefined;
         let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, {
-            name: name.d.value,
-            fullName: ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.d.value),
-            moduleName: fileInfo.moduleName,
-            fileUri: fileInfo.fileUri,
-            typeVarScopeId: typeAliasScopeId,
-            isPep695Syntax,
-            typeParams: typeParams.length > 0 ? typeParams : undefined,
-            usageVariance: undefined,
+            shared: sharedInfo,
             typeArgs: undefined,
         });
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
-        if (isPep695Syntax || isPep695TypeVarType) {
+        if (sharedInfo.isPep695Syntax || isPep695TypeVarType) {
             const typeAliasTypeClass = getTypingType(errorNode, 'TypeAliasType');
             if (typeAliasTypeClass && (0, types_1.isInstantiableClass)(typeAliasTypeClass)) {
                 typeAlias = types_1.TypeBase.cloneAsSpecialForm(typeAlias, types_1.ClassType.cloneAsInstance(typeAliasTypeClass));
@@ -11641,7 +11664,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeParamVariance: 2 /* Variance.Invariant */,
                 },
             ],
-            ['TypeForm', { alias: '', module: 'builtins', isSpecialForm: true, typeParamVariance: 3 /* Variance.Covariant */ }],
+            [
+                'TypeForm',
+                {
+                    alias: '',
+                    module: 'builtins',
+                    isSpecialForm: true,
+                    typeParamVariance: 3 /* Variance.Covariant */,
+                    isIllegalInIsinstance: true,
+                },
+            ],
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
@@ -11780,7 +11812,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (typeAliasNameNode) {
-                typeAliasPlaceholder = synthesizeTypeAliasPlaceholder(typeAliasNameNode);
+                typeAliasPlaceholder = synthesizeTypeAliasPlaceholder(typeAliasNameNode, /* isPep695Syntax */ false);
                 writeTypeCache(node, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 writeTypeCache(node.d.leftExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 if (node.d.leftExpr.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
@@ -11801,8 +11833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (typeAliasNameNode) {
                 (0, debug_1.assert)(typeAliasPlaceholder !== undefined);
                 // If this is a type alias, record its name based on the assignment target.
-                rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
-                /* isPep695Syntax */ false, 
+                rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasPlaceholder, 
                 /* isPep695TypeVarType */ false);
                 if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasPlaceholder, rightHandType)) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
@@ -11815,7 +11846,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeAliasPlaceholder.shared.boundType = rightHandType;
                 // Record the type parameters within the recursive type alias so it
                 // can be specialized.
-                typeAliasPlaceholder.shared.recursiveAlias.typeParams = (_b = (_a = rightHandType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeParams;
+                typeAliasPlaceholder.shared.recursiveAlias.typeParams =
+                    (_b = (_a = rightHandType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.shared.typeParams;
             }
             else {
                 // If the RHS is a constant boolean expression, assign it a literal type.
@@ -11835,17 +11867,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Synthesize a TypeVar that acts as a placeholder for a type alias. This allows
     // the type alias definition to refer to itself.
-    function synthesizeTypeAliasPlaceholder(nameNode) {
+    function synthesizeTypeAliasPlaceholder(nameNode, isPep695Syntax) {
         const placeholder = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.d.value}`);
         placeholder.shared.isSynthesized = true;
-        const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
+        const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
         placeholder.shared.recursiveAlias = {
             name: nameNode.d.value,
-            scopeId,
-            isPep695Syntax: false,
+            fullName: ParseTreeUtils.getClassFullName(nameNode, fileInfo.moduleName, nameNode.d.value),
+            moduleName: fileInfo.moduleName,
+            fileUri: fileInfo.fileUri,
+            typeVarScopeId,
+            isPep695Syntax,
             typeParams: undefined,
+            computedVariance: undefined,
         };
-        placeholder.priv.scopeId = scopeId;
+        placeholder.priv.scopeId = typeVarScopeId;
         return placeholder;
     }
     // Evaluates the type of a type alias (i.e. "type") statement. This code
@@ -11870,7 +11907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Synthesize a type variable that represents the type alias while we're
         // evaluating it. This allows us to handle recursive definitions.
-        const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(nameNode);
+        const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(nameNode, isPep695Syntax);
         // Write the type to the type cache to support recursive type alias definitions.
         writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
@@ -11893,8 +11930,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (aliasTypeResult.isIncomplete) {
             isIncomplete = true;
         }
-        aliasType = transformTypeForTypeAlias(aliasType, nameNode, nameNode, isPep695Syntax, 
-        /* isPep695TypeVarType */ true, typeParams, typeParamNodes);
+        aliasType = transformTypeForTypeAlias(aliasType, nameNode, typeAliasTypeVar, 
+        /* isPep695TypeVarType */ true, typeParamNodes);
         // See if the type alias relies on itself in a way that cannot be resolved.
         if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, aliasType)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
@@ -11922,6 +11959,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function createSubclass(errorNode, type1, type2) {
         var _a, _b;
         (0, debug_1.assert)((0, types_1.isInstantiableClass)(type1) && (0, types_1.isInstantiableClass)(type2));
+        // If both classes are class objects (type[A] and type[B]), create a new
+        // class object (type[A & B]) rather than "type[A] & type[B]".
+        let createClassObject = false;
+        if (types_1.TypeBase.getInstantiableDepth(type1) > 0 && types_1.TypeBase.getInstantiableDepth(type2) > 0) {
+            type1 = types_1.ClassType.cloneAsInstance(type1);
+            type2 = types_1.ClassType.cloneAsInstance(type2);
+            createClassObject = true;
+        }
         const className = `<subclass of ${printType((0, typeUtils_1.convertToInstance)(type1), {
             omitTypeArgsIfUnknown: true,
         })} and ${printType((0, typeUtils_1.convertToInstance)(type2), { omitTypeArgsIfUnknown: true })}>`;
@@ -11939,6 +11984,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         (0, typeUtils_1.computeMroLinearization)(newClassType);
         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_a = type1.props) === null || _a === void 0 ? void 0 : _a.condition);
         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, (_b = type2.props) === null || _b === void 0 ? void 0 : _b.condition);
+        if (createClassObject) {
+            newClassType = types_1.ClassType.cloneAsInstantiable(newClassType);
+        }
         return newClassType;
     }
     function getTypeOfClass(node) {
@@ -12780,7 +12828,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const paramMap = new Map();
                     for (let i = paramListDetails.firstKeywordOnlyIndex; i < paramListDetails.params.length; i++) {
                         const paramInfo = paramListDetails.params[i];
-                        if (paramInfo.param.category === 0 /* ParamCategory.Simple */ && paramInfo.param.name) {
+                        if (paramInfo.param.category === 0 /* ParamCategory.Simple */ &&
+                            paramInfo.param.name &&
+                            paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
                             paramMap.set(paramInfo.param.name, i);
                         }
                     }
@@ -13384,7 +13434,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 skipInference = true;
             }
             if (!skipInference) {
-                inferredParamType = convertSpecialFormToRuntimeValue(defaultValueType, 0 /* EvalFlags.None */);
+                inferredParamType = convertSpecialFormToRuntimeValue(defaultValueType, 0 /* EvalFlags.None */, 
+                /* convertModule */ true);
                 inferredParamType = (0, typeUtils_1.stripTypeForm)(inferredParamType);
                 inferredParamType = stripLiteralValue(inferredParamType);
             }
@@ -14373,7 +14424,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const typeAnnotation = ParseTreeUtils.getTypeAnnotationForParam(functionNode, paramIndex);
         if (typeAnnotation) {
             const param = functionNode.d.params[paramIndex];
-            const annotatedType = getTypeOfParamAnnotation(typeAnnotation, functionNode.d.params[paramIndex].d.category);
+            let annotatedType = getTypeOfParamAnnotation(typeAnnotation, functionNode.d.params[paramIndex].d.category);
+            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(param);
+            annotatedType = (0, typeUtils_1.makeTypeVarsBound)(annotatedType, liveTypeVarScopes);
             const adjType = transformVariadicParamType(node, node.d.category, adjustParamAnnotatedType(param, annotatedType));
             writeTypeCache(node.d.name, { type: adjType }, 0 /* EvalFlags.None */);
             return;
@@ -15420,7 +15473,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         else {
                             const synthesizedType = symbol.getSynthesizedType();
                             if (synthesizedType) {
-                                synthesizedTypes.push(synthesizedType);
+                                synthesizedTypes.push({ type: synthesizedType, node });
                             }
                             else {
                                 (0, collectionUtils_1.appendArray)(declarations, symbol.getDeclarations());
@@ -15509,7 +15562,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return { decls: declarations, synthesizedTypes };
     }
     function getTypeForDeclaration(declaration) {
-        var _a, _b;
+        var _a, _b, _c;
         switch (declaration.type) {
             case 0 /* DeclarationType.Intrinsic */: {
                 if (declaration.intrinsicType === 'Any') {
@@ -15570,12 +15623,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { type: getTypeOfTypeAlias(declaration.node) };
             }
             case 2 /* DeclarationType.Param */: {
-                let typeAnnotationNode = declaration.node.d.annotation || declaration.node.d.annotationComment;
+                let typeAnnotationNode = (_a = declaration.node.d.annotation) !== null && _a !== void 0 ? _a : declaration.node.d.annotationComment;
                 // If there wasn't an annotation, see if the parent function
                 // has a function-level annotation comment that provides
                 // this parameter's annotation type.
                 if (!typeAnnotationNode) {
-                    if (((_a = declaration.node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 31 /* ParseNodeType.Function */) {
+                    if (((_b = declaration.node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 31 /* ParseNodeType.Function */) {
                         const functionNode = declaration.node.parent;
                         if (functionNode.d.funcAnnotationComment &&
                             !functionNode.d.funcAnnotationComment.d.isEllipsis) {
@@ -15609,7 +15662,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         const declNode = declaration.isDefinedByMemberAccess &&
-                            ((_b = declaration.node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* ParseNodeType.MemberAccess */
+                            ((_c = declaration.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 35 /* ParseNodeType.MemberAccess */
                             ? declaration.node.parent
                             : declaration.node;
                         declaredType = getTypeOfAnnotation(typeAnnotationNode, {
@@ -15768,6 +15821,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 (0, debug_1.assert)(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */);
                 scopeType = 2 /* TypeVarScopeType.TypeAlias */;
+                typeVar.shared.declaredVariance = 0 /* Variance.Auto */;
             }
             typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */ ? scopeNode.d.name : scopeNode), scopeNode.d.name.d.value, scopeType);
         }
@@ -15904,8 +15958,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // in the event that its inferred type is instantiable or explicitly Any
                 // (but not an ellipsis).
                 if (isLegalImplicitTypeAliasType(inferredType)) {
-                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.typeAliasName, resolvedDecl.node, 
-                    /* isPep695Syntax */ false, 
+                    const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(resolvedDecl.typeAliasName, 
+                    /* isPep695Syntax */ false);
+                    inferredType = transformTypeForTypeAlias(inferredType, resolvedDecl.node, typeAliasTypeVar, 
                     /* isPep695TypeVarType */ false);
                     isUnambiguousType = true;
                 }
@@ -16033,7 +16088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     includesVariableDecl: includesVariableTypeDecl(typedDecls),
                     includesIllegalTypeAliasDecl: !typedDecls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
                     includesSpeculativeResult: false,
-                    isRecursiveDefinition: !declaredType,
+                    isRecursiveDefinition: !declaredType && !speculativeTypeTracker.isSpeculative(/* node */ undefined),
                 };
                 return result;
             }
@@ -16572,7 +16627,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramType = types_1.UnknownType.create();
                         }
                         if (stripLiteralArgTypes) {
-                            paramType = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(paramType), 0 /* EvalFlags.None */));
+                            paramType = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(paramType), 0 /* EvalFlags.None */, 
+                            /* convertModule */ true));
                         }
                         paramTypes.push(paramType);
                         writeTypeCache(param.d.name, { type: paramType }, 0 /* EvalFlags.None */);
@@ -16979,7 +17035,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // in this case. Adding more information is unnecessary and confusing.
             (flags & 1 /* AssignTypeFlags.Invariant */) === 0 ? diag : undefined, constraints, flags, recursionCount);
         }
-        if (constraints && curSrcType.priv.typeArgs && !constraints.isLocked()) {
+        if (constraints && curSrcType.priv.typeArgs) {
             // Populate the typeVar map with type arguments of the source.
             const srcTypeArgs = curSrcType.priv.typeArgs;
             for (let i = 0; i < destType.shared.typeParams.length; i++) {
@@ -17151,16 +17207,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Do the source and dest refer to the same recursive type alias?
             if ((destAliasInfo === null || destAliasInfo === void 0 ? void 0 : destAliasInfo.typeArgs) &&
                 (srcAliasInfo === null || srcAliasInfo === void 0 ? void 0 : srcAliasInfo.typeArgs) &&
-                destType.shared.recursiveAlias.scopeId === srcType.shared.recursiveAlias.scopeId) {
-                let isAssignable = true;
-                const srcTypeArgs = srcAliasInfo.typeArgs;
-                destAliasInfo.typeArgs.forEach((destTypeArg, index) => {
-                    const srcTypeArg = index < srcTypeArgs.length ? srcTypeArgs[index] : types_1.UnknownType.create();
-                    if (!assignType(destTypeArg, srcTypeArg, diag, constraints, flags, recursionCount)) {
-                        isAssignable = false;
-                    }
-                });
-                return isAssignable;
+                destType.shared.recursiveAlias.typeVarScopeId === srcType.shared.recursiveAlias.typeVarScopeId) {
+                return assignRecursiveTypeAliasToSelf(destAliasInfo, srcAliasInfo, diag, constraints, flags, recursionCount);
             }
             else {
                 // Have we already recursed once?
@@ -17676,6 +17724,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
+    // Determines whether a recursive type alias can be assigned to itself
+    // given the source and dest type args and computed variance for its
+    // type params.
+    function assignRecursiveTypeAliasToSelf(destAliasInfo, srcAliasInfo, diag, constraints, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
+        (0, debug_1.assert)(destAliasInfo.typeArgs !== undefined);
+        (0, debug_1.assert)(srcAliasInfo.typeArgs !== undefined);
+        let isAssignable = true;
+        const srcTypeArgs = srcAliasInfo.typeArgs;
+        const variances = destAliasInfo.shared.computedVariance;
+        destAliasInfo.typeArgs.forEach((destTypeArg, index) => {
+            const srcTypeArg = index < srcTypeArgs.length ? srcTypeArgs[index] : types_1.UnknownType.create();
+            let adjFlags = flags;
+            const variance = variances && index < variances.length ? variances[index] : 3 /* Variance.Covariant */;
+            if (variance === 2 /* Variance.Invariant */) {
+                adjFlags |= 1 /* AssignTypeFlags.Invariant */;
+            }
+            else if (variance === 4 /* Variance.Contravariant */) {
+                adjFlags ^= 2 /* AssignTypeFlags.Contravariant */;
+            }
+            if (!assignType(destTypeArg, srcTypeArg, diag, constraints, adjFlags, recursionCount)) {
+                isAssignable = false;
+            }
+        });
+        return isAssignable;
+    }
     // If the expected type is an explicit TypeForm type, see if the source
     // type has an implicit TypeForm type that can be assigned to it. If so,
     // convert to an explicit TypeForm type.
@@ -17921,9 +17994,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Finds unsolved type variables in the destType and establishes constraints
     // in the constraint tracker for them based on the srcType.
     function setConstraintsForFreeTypeVars(destType, srcType, constraints) {
-        if (constraints.isLocked()) {
-            return;
-        }
         const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(destType);
         typeVars.forEach((typeVar) => {
             if (!types_1.TypeVarType.isBound(typeVar) && !constraints.getMainConstraintSet().getTypeVar(typeVar)) {
@@ -18574,7 +18644,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (destParamDetails.firstKeywordOnlyIndex !== undefined) {
                 destParamDetails.params.forEach((param, index) => {
                     if (index >= destParamDetails.firstKeywordOnlyIndex) {
-                        if (param.param.name && param.param.category === 0 /* ParamCategory.Simple */) {
+                        if (param.param.name &&
+                            param.param.category === 0 /* ParamCategory.Simple */ &&
+                            param.kind !== parameterUtils_1.ParamKind.Positional) {
                             destParamMap.set(param.param.name, param);
                         }
                     }
@@ -19519,11 +19591,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // contain references to themselves or their subclasses, so if
                 // we attempt to call assignType, we'll risk infinite recursion.
                 // Instead, we'll assume it's assignable.
-                if (!constraints.isLocked()) {
-                    constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
-                        ? (0, typeUtils_1.convertToInstance)(firstParamType)
-                        : firstParamType);
-                }
+                constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
+                    ? (0, typeUtils_1.convertToInstance)(firstParamType)
+                    : firstParamType);
             }
             else {
                 const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();