@zzzen/pyright-internal 1.2.0-dev.20240908 → 1.2.0-dev.20240922

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;
@@ -490,6 +491,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');
@@ -567,6 +569,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 };
             }
         }
+        if (inferenceContext) {
+            // Handle TypeForm assignments.
+            typeResult.type = convertToTypeFormType(inferenceContext.expectedType, typeResult.type);
+        }
         // Don't allow speculative caching for assignment expressions because
         // the target name node won't have a corresponding type cached speculatively.
         const allowSpeculativeCaching = node.nodeType !== 4 /* ParseNodeType.AssignmentExpression */;
@@ -1720,6 +1726,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getDeclaredTypeForExpression(expression, usage) {
         var _a, _b;
         let symbol;
+        let selfType;
         let classOrObjectBase;
         let memberAccessClass;
         let bindFunction = true;
@@ -1752,11 +1759,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.
@@ -1765,11 +1773,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;
                 }
@@ -1810,11 +1821,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);
                         }
                     }
                 }
@@ -2026,6 +2039,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTupleClassType() {
         return tupleClass && (0, types_1.isInstantiableClass)(tupleClass) ? tupleClass : undefined;
     }
+    function getDictClassType() {
+        return dictClass && (0, types_1.isInstantiableClass)(dictClass) ? dictClass : undefined;
+    }
+    function getStrClassType() {
+        return strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : undefined;
+    }
     function getObjectType() {
         return objectClass ? (0, typeUtils_1.convertToInstance)(objectClass) : types_1.UnknownType.create();
     }
@@ -3185,7 +3204,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (((_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) && types_1.TypeBase.isInstantiable(type)) {
-            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(specializeTypeAliasWithDefaults(type, /* errorNode */ undefined)));
+            let typeFormType = type;
+            if ((flags & 2 /* EvalFlags.NoSpecialize */) === 0) {
+                typeFormType = specializeTypeAliasWithDefaults(typeFormType, /* errorNode */ undefined);
+            }
+            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(typeFormType));
         }
         return type;
     }
@@ -3222,13 +3245,17 @@ 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) {
@@ -3654,6 +3681,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Detect, report, and fill in missing type arguments if appropriate.
             typeResult.type = reportMissingTypeArgs(node, typeResult.type, flags);
+            // Add TypeForm details if appropriate.
+            typeResult.type = addTypeFormForSymbol(node, typeResult.type, flags, /* includesVarDecl */ false);
         }
         if (baseTypeResult.isIncomplete) {
             typeResult.isIncomplete = true;
@@ -3681,7 +3710,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.d.member.d.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -3694,12 +3723,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isRequired = false;
         const isNotRequired = false;
         let memberAccessDeprecationInfo;
+        if ((_a = usage === null || usage === void 0 ? void 0 : usage.setType) === null || _a === void 0 ? void 0 : _a.isIncomplete) {
+            isIncomplete = true;
+        }
         // If the base type was incomplete and unbound, don't proceed
         // because false positive errors will be generated.
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
-        if (((_a = baseType.props) === null || _a === void 0 ? void 0 : _a.specialForm) && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+        if (((_b = baseType.props) === null || _b === void 0 ? void 0 : _b.specialForm) && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             baseType = baseType.props.specialForm;
         }
         if ((0, types_1.isParamSpec)(baseType) && baseType.priv.paramSpecAccess) {
@@ -3777,7 +3809,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             types_1.ClassType.isSameGenericClass(enumMemberResult.type, baseType) &&
                             enumMemberResult.type.priv.literalValue !== undefined) {
                             const diagMessage = usage.method === 'set' ? localize_1.LocMessage.enumMemberSet() : localize_1.LocMessage.enumMemberDelete();
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, diagMessage.format({ name: memberName }) + diag.getString(), node.d.member, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node.d.member);
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, diagMessage.format({ name: memberName }) + diag.getString(), node.d.member, (_c = diag.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.member);
                         }
                     }
                 }
@@ -3980,7 +4012,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const rule = isFunctionRule
                     ? diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess
                     : diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue;
-                addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.d.member, (_c = diag.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.member);
+                addDiagnostic(rule, diagMessage.format({ name: memberName, type: printType(baseType) }) + diag.getString(), node.d.member, (_d = diag.getEffectiveTextRange()) !== null && _d !== void 0 ? _d : node.d.member);
             }
             // If this is member access on a function, use "Any" so if the
             // reportFunctionMemberAccess rule is disabled, we don't trigger
@@ -4251,8 +4283,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') {
@@ -4268,6 +4301,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)) {
@@ -4830,13 +4866,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Handles index expressions that are providing type arguments for a
     // generic type alias.
     function createSpecializedTypeAlias(node, baseType, flags) {
-        var _a, _b, _c;
-        const aliasInfo = (_a = baseType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        var _a, _b, _c, _d, _e, _f, _g;
+        let aliasInfo = (_a = baseType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        let aliasBaseType = baseType;
+        if (!aliasInfo && ((_b = baseType.props) === null || _b === void 0 ? void 0 : _b.typeForm)) {
+            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)) {
             return undefined;
         }
         // If this is not instantiable, then the index expression isn't a specialization.
-        if (!types_1.TypeBase.isInstantiable(baseType)) {
+        if (!types_1.TypeBase.isInstantiable(aliasBaseType)) {
             return undefined;
         }
         // If this is already specialized, the index expression isn't a specialization.
@@ -4868,7 +4909,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (typeArgs.length > typeParams.length) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
-                name: printType(baseType),
+                name: printType(aliasBaseType),
                 expected: typeParams.length,
                 received: typeArgs.length,
             }), typeArgs[typeParams.length].node);
@@ -4876,15 +4917,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else if (typeArgs.length < minTypeArgCount) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooFew().format({
-                name: printType(baseType),
+                name: printType(aliasBaseType),
                 expected: typeParams.length,
                 received: typeArgs.length,
             }), node.d.items[node.d.items.length - 1]);
             reportedError = true;
         }
         // Handle the mypy_extensions.FlexibleAlias type specially.
-        if ((0, types_1.isInstantiableClass)(baseType) &&
-            baseType.shared.fullName === 'mypy_extensions.FlexibleAlias' &&
+        if ((0, types_1.isInstantiableClass)(aliasBaseType) &&
+            aliasBaseType.shared.fullName === 'mypy_extensions.FlexibleAlias' &&
             typeArgs.length >= 1) {
             return { node, type: typeArgs[0].type };
         }
@@ -4960,7 +5001,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeArgType = types_1.UnknownType.create();
                 }
                 if ((flags & 16384 /* EvalFlags.EnforceVarianceConsistency */) !== 0) {
-                    const usageVariances = inferVarianceForTypeAlias(baseType);
+                    const usageVariances = inferVarianceForTypeAlias(aliasBaseType);
                     if (usageVariances && index < usageVariances.length) {
                         const usageVariance = usageVariances[index];
                         if (!(0, typeUtils_1.isVarianceOfTypeArgCompatible)(typeArgType, usageVariance)) {
@@ -4983,12 +5024,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         });
         if (!diag.isEmpty()) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeNotSpecializable().format({ type: printType(aliasBaseType) }) + diag.getString(), node, (_e = diag.getEffectiveTextRange()) !== null && _e !== void 0 ? _e : node);
             reportedError = true;
         }
         const solutionSet = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
         const aliasTypeArgs = [];
-        (_c = aliasInfo.typeParams) === null || _c === void 0 ? void 0 : _c.forEach((typeParam) => {
+        (_f = aliasInfo.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) {
@@ -4997,14 +5038,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             aliasTypeArgs.push(typeVarType);
         });
-        let type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(baseType, constraints), {
+        let type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(aliasBaseType, constraints), {
             ...aliasInfo,
             typeArgs: aliasTypeArgs,
         });
         if (isTypeFormSupported(node)) {
             type = types_1.TypeBase.cloneWithTypeForm(type, reportedError ? undefined : (0, typeUtils_1.convertToInstance)(type));
         }
-        return { type, node };
+        if ((_g = baseType.props) === null || _g === void 0 ? void 0 : _g.typeAliasInfo) {
+            return { type, node };
+        }
+        return { type: types_1.TypeBase.cloneWithTypeForm(baseType, (0, typeUtils_1.convertToInstance)(type)), node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
         var _a, _b, _c;
@@ -5759,7 +5803,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 });
             }
@@ -5826,7 +5871,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if ((0, types_1.isClass)(baseTypeResult.type) && types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeForm')) {
                 // Handle the "typing.TypeForm" call.
-                typeResult = getTypeOfTypeForm(node);
+                typeResult = getTypeOfTypeForm(node, baseTypeResult.type);
             }
             else if ((0, types_1.isAnyOrUnknown)(baseTypeResult.type) &&
                 node.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
@@ -5931,21 +5976,25 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function getTypeOfTypeForm(node) {
+    function getTypeOfTypeForm(node, typeFormClass) {
+        var _a;
         if (node.d.args.length !== 1 ||
             node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
             node.d.args[0].d.name !== undefined) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeFormArgs(), node);
             return { type: types_1.UnknownType.create() };
         }
-        return getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[0]), {
+        const typeFormResult = getTypeOfArgExpectingType((0, typeUtils_1.convertNodeToArg)(node.d.args[0]), {
             typeFormArg: isTypeFormSupported(node),
             noNonTypeSpecialForms: true,
             typeExpression: true,
         });
+        if (!typeFormResult.typeErrors && ((_a = typeFormResult.type.props) === null || _a === void 0 ? void 0 : _a.typeForm)) {
+            typeFormResult.type = (0, typeUtils_1.convertToInstance)(types_1.ClassType.specialize(typeFormClass, [(0, typeUtils_1.convertToInstance)(typeFormResult.type.props.typeForm)]));
+        }
+        return typeFormResult;
     }
     function getTypeOfAssertType(node, inferenceContext) {
-        var _a;
         if (node.d.args.length !== 2 ||
             node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
             node.d.args[0].d.name !== undefined ||
@@ -5965,24 +6014,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // The spec is unclear on whether this is the correct behavior, but it seems to be
         // what mypy does -- and what various library authors expect.
         const arg0Type = stripTypeGuard(arg0TypeResult.type);
-        let assertSuccess = (0, types_1.isTypeSame)(assertedType, arg0Type, {
+        if (!(0, types_1.isTypeSame)(assertedType, arg0Type, {
             treatAnySameAsUnknown: true,
             ignorePseudoGeneric: true,
-        });
-        // Handle TypeForm types specially.
-        if (!assertSuccess &&
-            ((_a = arg0Type.props) === null || _a === void 0 ? void 0 : _a.typeForm) &&
-            (0, types_1.isClassInstance)(assertedType) &&
-            types_1.ClassType.isBuiltIn(assertedType, 'TypeForm')) {
-            const typeFormType = assertedType.priv.typeArgs && assertedType.priv.typeArgs.length >= 1
-                ? assertedType.priv.typeArgs[0]
-                : types_1.UnknownType.create();
-            assertSuccess = (0, types_1.isTypeSame)(arg0Type.props.typeForm, typeFormType, {
-                treatAnySameAsUnknown: true,
-                ignorePseudoGeneric: true,
-            });
-        }
-        if (!assertSuccess) {
+        })) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
@@ -6386,7 +6421,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, () => {
@@ -6498,7 +6532,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;
@@ -6672,7 +6705,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,
@@ -7066,27 +7098,25 @@ 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.isInstantiableClass)(subtype) && subtype.shared.effectiveMetaclass) {
-                            return subtype.shared.effectiveMetaclass;
-                        }
                         if ((0, types_1.isNever)(subtype)) {
                             return subtype;
                         }
+                        if ((0, types_1.isClass)(subtype)) {
+                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
+                        }
                         if (types_1.TypeBase.isInstance(subtype)) {
-                            if ((0, types_1.isClass)(subtype) || (0, types_1.isTypeVar)(subtype)) {
-                                return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
-                            }
-                            if ((0, types_1.isFunction)(subtype)) {
-                                return types_1.FunctionType.cloneAsInstantiable(subtype);
+                            if ((0, types_1.isFunction)(subtype) || (0, types_1.isTypeVar)(subtype)) {
+                                return (0, typeUtils_1.convertToInstantiable)(subtype);
                             }
                         }
                         return types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(expandedCallType), [
                             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
@@ -8377,9 +8407,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;
@@ -9683,8 +9710,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
@@ -10035,7 +10062,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;
             }
@@ -11908,6 +11935,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 })}>`;
@@ -11925,6 +11960,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) {
@@ -13370,7 +13408,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);
             }
@@ -14359,7 +14398,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;
@@ -15406,7 +15447,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());
@@ -15495,7 +15536,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') {
@@ -15556,12 +15597,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) {
@@ -15595,7 +15636,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, {
@@ -16019,7 +16060,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;
             }
@@ -16558,7 +16599,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 */);
@@ -16965,7 +17007,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++) {
@@ -17046,6 +17088,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // why two types are not the same.
                 includeDiagAddendum = false;
             }
+            // Special-case TypeForm to retain literals when solving TypeVars.
+            if (types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
+                effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+            }
             if (!assignType(variance === 4 /* Variance.Contravariant */ ? srcTypeArg : destTypeArg, variance === 4 /* Variance.Contravariant */ ? destTypeArg : srcTypeArg, assignmentDiag, constraints, effectiveFlags, recursionCount)) {
                 // Don't report errors with type variables in "pseudo-random"
                 // classes since these type variables are not real.
@@ -17154,6 +17200,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 flags |= 4 /* AssignTypeFlags.SkipRecursiveTypeCheck */;
             }
         }
+        // If one or both of the types has an instantiable depth greater than
+        // zero, convert both to instances first.
+        if (types_1.TypeBase.isInstantiable(destType) && types_1.TypeBase.isInstantiable(srcType)) {
+            if (types_1.TypeBase.getInstantiableDepth(destType) > 0 || types_1.TypeBase.getInstantiableDepth(srcType) > 0) {
+                return assignType((0, typeUtils_1.convertToInstance)(destType), (0, typeUtils_1.convertToInstance)(srcType), diag, constraints, flags, recursionCount);
+            }
+        }
         // Transform recursive type aliases if necessary.
         const transformedDestType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(destType);
         const transformedSrcType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(srcType);
@@ -17179,10 +17232,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnbound)(destType) || (0, types_1.isUnbound)(srcType)) {
             return true;
         }
-        // Handle TypeForm assignments.
-        if (assignToTypeFormType(destType, srcType, constraints, flags, recursionCount)) {
-            return true;
-        }
         if ((0, types_1.isTypeVar)(destType)) {
             if ((0, typeUtils_1.isTypeVarSame)(destType, srcType)) {
                 return true;
@@ -17327,7 +17376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If both the source and dest are unions, use assignFromUnionType which has
             // special-case logic to handle this case.
             if ((0, types_1.isUnion)(srcType)) {
-                return assignFromUnionType(destType, srcType, /* diag */ undefined, constraints, flags, recursionCount);
+                return assignFromUnionType(destType, srcType, diag, constraints, flags, recursionCount);
             }
             const clonedConstraints = constraints === null || constraints === void 0 ? void 0 : constraints.clone();
             if (assignToUnionType(destType, srcType, /* diag */ undefined, clonedConstraints, flags, recursionCount)) {
@@ -17372,7 +17421,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // PEP 544 says that if the dest type is a type[Proto] class,
                 // the source must be a "concrete" (non-protocol) class.
                 if (types_1.ClassType.isProtocolClass(destType)) {
-                    if (types_1.ClassType.isProtocolClass(expandedSrcType) &&
+                    if ((flags & 65536 /* AssignTypeFlags.AllowProtocolClassSource */) === 0 &&
+                        types_1.ClassType.isProtocolClass(expandedSrcType) &&
                         (0, types_1.isInstantiableClass)(srcType) &&
                         !srcType.priv.includeSubclasses) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.protocolSourceIsNotConcrete().format({
@@ -17416,7 +17466,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, types_1.isClassInstance)(destType)) {
             if (types_1.ClassType.isBuiltIn(destType, 'type')) {
-                if ((0, types_1.isInstantiableClass)(srcType) && isSpecialFormClass(srcType, flags)) {
+                if ((0, types_1.isInstantiableClass)(srcType) &&
+                    isSpecialFormClass(srcType, flags) &&
+                    types_1.TypeBase.getInstantiableDepth(srcType) === 0) {
                     return false;
                 }
                 if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
@@ -17652,20 +17704,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
-    // If the destination type is an explicit TypeForm type, see if the source
-    // type has an implicit TypeForm type that can be assigned to it. Also see
-    // of the source is a type[T] type that is assignable.
-    function assignToTypeFormType(destType, srcType, constraints, flags, recursionCount) {
-        var _a, _b;
-        if (!(0, types_1.isClassInstance)(destType) || !types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
-            return false;
+    // 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.
+    function convertToTypeFormType(expectedType, srcType) {
+        var _a, _b, _c;
+        // Is the source is a TypeForm type?
+        if (!((_a = srcType.props) === null || _a === void 0 ? void 0 : _a.typeForm)) {
+            return srcType;
         }
-        const destTypeFormType = destType.priv.typeArgs && destType.priv.typeArgs.length > 0
-            ? destType.priv.typeArgs[0]
-            : types_1.UnknownType.create();
         let srcTypeFormType;
         // Is the source is a TypeForm type?
-        if ((_a = srcType.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+        if ((_b = srcType.props) === null || _b === void 0 ? void 0 : _b.typeForm) {
             srcTypeFormType = srcType.props.typeForm;
         }
         else if ((0, types_1.isClass)(srcType)) {
@@ -17676,7 +17726,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if (types_1.ClassType.isBuiltIn(srcType, 'type')) {
                 srcTypeFormType =
-                    ((_b = srcType.priv.typeArgs) === null || _b === void 0 ? void 0 : _b.length) && srcType.priv.typeArgs.length > 0
+                    ((_c = srcType.priv.typeArgs) === null || _c === void 0 ? void 0 : _c.length) && srcType.priv.typeArgs.length > 0
                         ? srcType.priv.typeArgs[0]
                         : types_1.UnknownType.create();
             }
@@ -17687,9 +17737,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!srcTypeFormType) {
-            return false;
+            return srcType;
         }
-        return assignType(destTypeFormType, srcTypeFormType, /* diag */ undefined, constraints, flags, recursionCount);
+        let resultType;
+        (0, typeUtils_1.doForEachSubtype)(expectedType, (subtype) => {
+            if (resultType || !(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'TypeForm')) {
+                return;
+            }
+            const destTypeFormType = subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0
+                ? subtype.priv.typeArgs[0]
+                : types_1.UnknownType.create();
+            if (assignType(destTypeFormType, srcTypeFormType)) {
+                resultType = types_1.ClassType.specialize(subtype, [srcTypeFormType]);
+            }
+        });
+        return resultType !== null && resultType !== void 0 ? resultType : srcType;
     }
     function assignFromUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         // Start by checking for an exact match. This is needed to handle unions
@@ -17887,9 +17949,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)) {
@@ -19485,11 +19544,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();
@@ -19830,6 +19887,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getBoundMagicMethod,
         getTypeOfMagicMethodCall,
         bindFunctionToClassOrObject,
+        getCallbackProtocolType,
         getCallSignatureInfo,
         getAbstractSymbols,
         narrowConstrainedTypeVar,
@@ -19841,6 +19899,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         assignClassToSelf,
         getTypedDictClassType,
         getTupleClassType,
+        getDictClassType,
+        getStrClassType,
         getObjectType,
         getNoneType,
         getUnionClassType,