@zzzen/pyright-internal 1.2.0-dev.20240623 → 1.2.0-dev.20240707

package/dist/analyzer/typeEvaluator.js

@@ -303,7 +303,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function setTypeResultForNode(node, typeResult, flags = 0 /* EvaluatorFlags.None */) {
+    function setTypeResultForNode(node, typeResult, flags = 0 /* EvalFlags.None */) {
         writeTypeCache(node, typeResult, flags);
     }
     function setAsymmetricDescriptorAssignment(node) {
@@ -419,7 +419,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
-        return readTypeCache(node, 0 /* EvaluatorFlags.None */);
+        return readTypeCache(node, 0 /* EvalFlags.None */);
     }
     // Determines the expected type of a specified node based on surrounding
     // context. For example, if it's a subexpression of an argument expression,
@@ -487,7 +487,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Wire up the `Any` class to the special-form version of our internal AnyType.
             if (objectClass && (0, types_1.isInstantiableClass)(objectClass) && typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
-                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ | 8388608 /* ClassTypeFlags.SpecialFormClass */, 
+                const anyClass = types_1.ClassType.createInstantiable('Any', 'typing.Any', 'typing', uri_1.Uri.empty(), 1 /* ClassTypeFlags.BuiltInClass */ |
+                    8388608 /* ClassTypeFlags.SpecialFormClass */ |
+                    16777216 /* ClassTypeFlags.IllegalIsinstanceClass */, 
                 /* typeSourceId */ -1, 
                 /* declaredMetaclass */ undefined, 
                 /* effectiveMetaclass */ typeClass);
@@ -500,7 +502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function getTypeOfExpression(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext, signatureTracker) {
+    function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext, signatureTracker) {
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -584,9 +586,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeResult;
     }
     // This is a helper function that implements the core of getTypeOfExpression.
-    function getTypeOfExpressionCore(node, flags = 0 /* EvaluatorFlags.None */, inferenceContext, signatureTracker) {
+    function getTypeOfExpressionCore(node, flags = 0 /* EvalFlags.None */, inferenceContext, signatureTracker) {
         let typeResult;
-        let expectingInstantiable = (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0;
+        let expectingInstantiable = (flags & 128 /* EvalFlags.InstantiableType */) !== 0;
         switch (node.nodeType) {
             case 38 /* ParseNodeType.Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -613,7 +615,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 48 /* ParseNodeType.StringList */: {
-                const isExpectingType = (flags & 8 /* EvaluatorFlags.EvaluateStringLiteralAsType */) !== 0 && !isAnnotationLiteralValue(node);
+                const isExpectingType = (flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && !isAnnotationLiteralValue(node);
                 if (isExpectingType) {
                     // Don't report expecting type errors again. We will have already
                     // reported them when analyzing the contents of the string.
@@ -639,7 +641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If we're expecting an instantiable type and this isn't a union operator,
                 // don't require that the two operands are also instantiable types.
                 if (expectingInstantiable && node.operator !== 6 /* OperatorType.BitwiseOr */) {
-                    effectiveFlags &= ~128 /* EvaluatorFlags.ExpectingInstantiableType */;
+                    effectiveFlags &= ~128 /* EvalFlags.InstantiableType */;
                 }
                 typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext);
                 break;
@@ -685,7 +687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
-                if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     addError(localize_1.LocMessage.walrusNotAllowed(), node);
                 }
                 typeResult = getTypeOfExpression(node.rightExpression, flags, inferenceContext, signatureTracker);
@@ -705,12 +707,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 54 /* ParseNodeType.TypeAnnotation */: {
-                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-                    256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-                    8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                    32 /* EvaluatorFlags.DisallowParamSpec */ |
-                    64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                    32768 /* EvaluatorFlags.VariableTypeAnnotation */);
+                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* EvalFlags.InstantiableType */ |
+                    256 /* EvalFlags.TypeExpression */ |
+                    8 /* EvalFlags.StrLiteralAsType */ |
+                    32 /* EvalFlags.NoParamSpec */ |
+                    64 /* EvalFlags.NoTypeVarTuple */ |
+                    32768 /* EvalFlags.VarTypeAnnotation */);
                 break;
             }
             case 49 /* ParseNodeType.String */:
@@ -742,7 +744,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If this is a PEP 695 type alias, remove the special form so the type
         // printer prints it as its aliased type rather than TypeAliasType.
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
             if (typeResult.type.specialForm && types_1.ClassType.isBuiltIn(typeResult.type.specialForm, 'TypeAliasType')) {
                 typeResult.type = types_1.TypeBase.cloneAsSpecialForm(typeResult.type, undefined);
             }
@@ -775,26 +777,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (typeResult.isIncomplete) {
             return;
         }
-        if (flags & 64 /* EvaluatorFlags.DisallowTypeVarTuple */) {
+        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) !== 0) {
             if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
                 addError(localize_1.LocMessage.typeVarTupleContext(), node);
                 typeResult.type = types_1.UnknownType.create();
             }
         }
-        if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
-            const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
-                types_1.ClassType.isTupleClass(typeResult.type) &&
-                ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-            const isEllipsis = (0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis']);
-            if (!isEmptyVariadic && !isEllipsis) {
-                addExpectedClassDiagnostic(typeResult.type, node);
-                typeResult.type = types_1.UnknownType.create();
-                typeResult.typeErrors = true;
-            }
+        if ((0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type, { honorTypeVarBounds: true })) {
+            return;
+        }
+        // Exempt ellipses.
+        if ((0, types_1.isClassInstance)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, ['EllipsisType', 'ellipsis'])) {
+            return;
         }
+        // Exempt empty tuples, which can be used for specializing a TypeVarTuple.
+        if ((0, types_1.isClassInstance)(typeResult.type) && ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+            return;
+        }
+        const diag = new diagnostic_1.DiagnosticAddendum();
+        if ((0, types_1.isUnion)(typeResult.type)) {
+            (0, typeUtils_1.doForEachSubtype)(typeResult.type, (subtype) => {
+                if (!(0, typeUtils_1.isEffectivelyInstantiable)(subtype, { honorTypeVarBounds: true })) {
+                    diag.addMessage(localize_1.LocAddendum.typeNotClass().format({ type: printType(subtype) }));
+                }
+            });
+        }
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeExpectedClass().format({ type: printType(typeResult.type) }) + diag.getString(), node);
+        typeResult.type = types_1.UnknownType.create();
+        typeResult.typeErrors = true;
     }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
             addError(localize_1.LocMessage.awaitNotAllowed(), node);
             return { type: types_1.UnknownType.create() };
         }
@@ -816,7 +829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfEllipsis(flags, typeResult, node) {
         var _a, _b;
-        if ((flags & 1 /* EvaluatorFlags.ConvertEllipsisToAny */) !== 0) {
+        if ((flags & 1 /* EvalFlags.ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
         else {
@@ -850,17 +863,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const iterTypeResult = getTypeOfExpression(node.expression, flags, (0, typeUtils_1.makeInferenceContext)(iterExpectedType));
         const iterType = iterTypeResult.type;
-        if ((flags & 64 /* EvaluatorFlags.DisallowTypeVarTuple */) === 0 &&
-            (0, types_1.isVariadicTypeVar)(iterType) &&
-            !iterType.isVariadicUnpacked) {
+        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isVariadicTypeVar)(iterType) && !iterType.isVariadicUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
-        else if ((flags & 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */) !== 0 &&
+        else if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
             (0, types_1.isInstantiableClass)(iterType) &&
             types_1.ClassType.isBuiltIn(iterType, 'tuple')) {
             typeResult = { type: types_1.ClassType.cloneForUnpacked(iterType) };
         }
-        else if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+        else if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
             addError(localize_1.LocMessage.unpackInAnnotation(), node, node.starToken);
             typeResult = { type: types_1.UnknownType.create() };
         }
@@ -881,11 +892,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfStringList(node, flags, isExpectingType) {
         let typeResult;
         if (isExpectingType) {
-            let updatedFlags = flags | 4 /* EvaluatorFlags.AllowForwardReferences */ | 128 /* EvaluatorFlags.ExpectingInstantiableType */;
+            let updatedFlags = flags | 4 /* EvalFlags.ForwardRefs */ | 128 /* EvalFlags.InstantiableType */;
             // In most cases, annotations within a string are not parsed by the interpreter.
             // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
-            if ((flags & 4194304 /* EvaluatorFlags.InterpreterParsesStringLiteral */) === 0) {
-                updatedFlags |= 524288 /* EvaluatorFlags.NotParsedByInterpreter */;
+            if ((flags & 8388608 /* EvalFlags.ParsesStringLiteral */) === 0) {
+                updatedFlags |= 524288 /* EvalFlags.NotParsed */;
             }
             if (node.typeAnnotation) {
                 typeResult = getTypeOfExpression(node.typeAnnotation, updatedFlags);
@@ -1068,59 +1079,59 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return specialType;
             }
         }
-        let evaluatorFlags = 128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-            256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-            1 /* EvaluatorFlags.ConvertEllipsisToAny */ |
-            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */;
+        let evaluatorFlags = 128 /* EvalFlags.InstantiableType */ |
+            256 /* EvalFlags.TypeExpression */ |
+            1 /* EvalFlags.ConvertEllipsisToAny */ |
+            8 /* EvalFlags.StrLiteralAsType */;
         if (options === null || options === void 0 ? void 0 : options.isVariableAnnotation) {
-            evaluatorFlags |= 32768 /* EvaluatorFlags.VariableTypeAnnotation */;
+            evaluatorFlags |= 32768 /* EvalFlags.VarTypeAnnotation */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowFinal)) {
-            evaluatorFlags |= 16 /* EvaluatorFlags.DisallowFinal */;
+            evaluatorFlags |= 16 /* EvalFlags.NoFinal */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowClassVar)) {
-            evaluatorFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */;
+            evaluatorFlags |= 131072 /* EvalFlags.NoClassVar */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarTuple)) {
-            evaluatorFlags |= 64 /* EvaluatorFlags.DisallowTypeVarTuple */;
+            evaluatorFlags |= 64 /* EvalFlags.NoTypeVarTuple */;
         }
         else {
-            evaluatorFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */;
+            evaluatorFlags |= 2097152 /* EvalFlags.AllowUnpackedTuple */;
         }
         if (!(options === null || options === void 0 ? void 0 : options.allowParamSpec)) {
-            evaluatorFlags |= 32 /* EvaluatorFlags.DisallowParamSpec */;
+            evaluatorFlags |= 32 /* EvalFlags.NoParamSpec */;
         }
         if (options === null || options === void 0 ? void 0 : options.associateTypeVarsWithScope) {
-            evaluatorFlags |= 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */;
+            evaluatorFlags |= 8192 /* EvalFlags.TypeVarGetsCurScope */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
-            evaluatorFlags |= 8388608 /* EvaluatorFlags.AllowUnpackedTypedDict */;
+            evaluatorFlags |= 4194304 /* EvalFlags.AllowUnpackedTypedDict */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
-            evaluatorFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */;
+            evaluatorFlags |= 2097152 /* EvalFlags.AllowUnpackedTuple */;
         }
         if (options === null || options === void 0 ? void 0 : options.notParsedByInterpreter) {
-            evaluatorFlags |= 524288 /* EvaluatorFlags.NotParsedByInterpreter */;
+            evaluatorFlags |= 524288 /* EvalFlags.NotParsed */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
-            evaluatorFlags |= 1048576 /* EvaluatorFlags.AllowRequired */;
+            evaluatorFlags |= 1048576 /* EvalFlags.AllowRequired */;
         }
         if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo)) {
-            evaluatorFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
+            evaluatorFlags |= 4 /* EvalFlags.ForwardRefs */;
         }
         // If the annotation is part of a comment, allow forward references
         // even if it's not enclosed in quotes.
         if (((_a = node === null || node === void 0 ? void 0 : node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* ParseNodeType.Assignment */ && node.parent.typeAnnotationComment === node) {
-            evaluatorFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */ | 524288 /* EvaluatorFlags.NotParsedByInterpreter */;
+            evaluatorFlags |= 4 /* EvalFlags.ForwardRefs */ | 524288 /* EvalFlags.NotParsed */;
         }
         else if (((_b = node === null || node === void 0 ? void 0 : node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 62 /* ParseNodeType.FunctionAnnotation */) {
             if (node.parent.returnTypeAnnotation === node || node.parent.paramTypeAnnotations.some((n) => n === node)) {
-                evaluatorFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */ | 524288 /* EvaluatorFlags.NotParsedByInterpreter */;
+                evaluatorFlags |= 4 /* EvalFlags.ForwardRefs */ | 524288 /* EvalFlags.NotParsed */;
             }
         }
         else if (((_c = node === null || node === void 0 ? void 0 : node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 41 /* ParseNodeType.Parameter */) {
             if (node.parent.typeAnnotationComment === node) {
-                evaluatorFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */ | 524288 /* EvaluatorFlags.NotParsedByInterpreter */;
+                evaluatorFlags |= 4 /* EvalFlags.ForwardRefs */ | 524288 /* EvalFlags.NotParsed */;
             }
         }
         const annotationType = getTypeOfExpression(node, evaluatorFlags).type;
@@ -1721,7 +1732,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return getDeclaredTypeForExpression(expression.valueExpression, usage);
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.leftExpression, 2 /* EvalFlags.MemberAccessBaseDefaults */).type);
                 let classMemberInfo;
                 if ((0, types_1.isClassInstance)(baseType)) {
                     classMemberInfo = (0, typeUtils_1.lookUpObjectMember)(baseType, expression.memberName.value, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
@@ -1745,7 +1756,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 27 /* ParseNodeType.Index */: {
-                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */).type);
+                const baseType = makeTopLevelTypeVarsConcrete(getTypeOfExpression(expression.baseExpression, 2 /* EvalFlags.IndexBaseDefaults */).type);
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
                     const setItemType = getBoundMagicMethod(baseType, '__setitem__');
                     if (setItemType && (0, types_1.isFunction)(setItemType) && setItemType.details.parameters.length >= 2) {
@@ -2217,17 +2228,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return diagnostic;
     }
-    function addExpectedClassDiagnostic(type, node) {
-        const diag = new diagnostic_1.DiagnosticAddendum();
-        if ((0, types_1.isUnion)(type)) {
-            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                if (!(0, typeUtils_1.isEffectivelyInstantiable)(subtype)) {
-                    diag.addMessage(localize_1.LocAddendum.typeNotClass().format({ type: printType(subtype) }));
-                }
-            });
-        }
-        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeExpectedClass().format({ type: printType(type) }) + diag.getString(), node);
-    }
     function assignTypeToNameNode(nameNode, typeResult, ignoreEmptyContainers, srcExpression, allowAssignmentToFinalVar = false, expectedTypeDiagAddendum) {
         var _a, _b, _c;
         const nameValue = nameNode.value;
@@ -2310,11 +2310,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!typeResult.isIncomplete) {
             reportPossibleUnknownAssignment(fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, nameNode, destType, nameNode, ignoreEmptyContainers);
         }
-        writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function assignTypeToMemberAccessNode(target, typeResult, srcExpr, expectedTypeDiagAddendum) {
         var _a;
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, 2 /* EvalFlags.MemberAccessBaseDefaults */);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
         // Handle member accesses (e.g. self.x or cls.y).
         if (target.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
@@ -2354,7 +2354,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             setType: typeResult,
             setErrorNode: srcExpr,
             setExpectedTypeDiag: expectedTypeDiagAddendum,
-        }, 0 /* EvaluatorFlags.None */);
+        }, 0 /* EvalFlags.None */);
         if (setTypeResult.isAsymmetricAccessor) {
             setAsymmetricDescriptorAssignment(target);
         }
@@ -2363,8 +2363,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isIncomplete: typeResult.isIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
-        writeTypeCache(target.memberName, resultToCache, 0 /* EvaluatorFlags.None */);
-        writeTypeCache(target, resultToCache, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(target.memberName, resultToCache, 0 /* EvalFlags.None */);
+        writeTypeCache(target, resultToCache, 0 /* EvalFlags.None */);
     }
     function assignTypeToMemberVariable(node, typeResult, isInstanceMember, srcExprNode) {
         var _a;
@@ -2539,7 +2539,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             assignTypeToExpression(expr, { type: targetType, isIncomplete: typeResult.isIncomplete }, srcExpr, 
             /* ignoreEmptyContainers */ true);
         });
-        writeTypeCache(target, typeResult, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(target, typeResult, 0 /* EvalFlags.None */);
     }
     // If the type includes promotion types, expand these to their constituent types.
     function expandPromotionTypes(node, type, excludeBytes = false) {
@@ -2767,7 +2767,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Is the source expression a TypeVar() call?
         if ((0, types_1.isTypeVar)(typeResult.type)) {
             if (srcExpr && srcExpr.nodeType === 9 /* ParseNodeType.Call */) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, 2 /* EvalFlags.CallBaseDefaults */).type;
                 if ((0, types_1.isInstantiableClass)(callType) &&
                     (types_1.ClassType.isBuiltIn(callType, 'TypeVar') ||
                         types_1.ClassType.isBuiltIn(callType, 'TypeVarTuple') ||
@@ -2802,14 +2802,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 27 /* ParseNodeType.Index */: {
-                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */);
+                const baseTypeResult = getTypeOfExpression(target.baseExpression, 2 /* EvalFlags.IndexBaseDefaults */);
                 getTypeOfIndexWithBaseType(target, baseTypeResult, {
                     method: 'set',
                     setType: typeResult,
                     setErrorNode: srcExpr,
                     setExpectedTypeDiag: expectedTypeDiagAddendum,
-                }, 0 /* EvaluatorFlags.None */);
-                writeTypeCache(target, typeResult, 0 /* EvaluatorFlags.None */);
+                }, 0 /* EvalFlags.None */);
+                writeTypeCache(target, typeResult, 0 /* EvalFlags.None */);
                 break;
             }
             case 34 /* ParseNodeType.List */:
@@ -2931,20 +2931,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 35 /* ParseNodeType.MemberAccess */: {
-                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.MemberAccessBaseDefaults */);
-                const delAccessResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvaluatorFlags.None */);
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvalFlags.MemberAccessBaseDefaults */);
+                const delAccessResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvalFlags.None */);
                 const resultToCache = {
                     type: delAccessResult.type,
                     memberAccessDeprecationInfo: delAccessResult.memberAccessDeprecationInfo,
                 };
-                writeTypeCache(node.memberName, resultToCache, 0 /* EvaluatorFlags.None */);
-                writeTypeCache(node, resultToCache, 0 /* EvaluatorFlags.None */);
+                writeTypeCache(node.memberName, resultToCache, 0 /* EvalFlags.None */);
+                writeTypeCache(node, resultToCache, 0 /* EvalFlags.None */);
                 break;
             }
             case 27 /* ParseNodeType.Index */: {
-                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* EvaluatorFlags.IndexBaseDefaults */);
-                getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvaluatorFlags.None */);
-                writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* EvaluatorFlags.None */);
+                const baseTypeResult = getTypeOfExpression(node.baseExpression, 2 /* EvalFlags.IndexBaseDefaults */);
+                getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, 0 /* EvalFlags.None */);
+                writeTypeCache(node, { type: types_1.UnboundType.create() }, 0 /* EvalFlags.None */);
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
@@ -2980,17 +2980,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let symbol;
         let type;
         let isIncomplete = false;
-        const allowForwardReferences = (flags & 4 /* EvaluatorFlags.AllowForwardReferences */) !== 0 || fileInfo.isStubFile;
+        const allowForwardReferences = (flags & 4 /* EvalFlags.ForwardRefs */) !== 0 || fileInfo.isStubFile;
         // Look for the scope that contains the value definition and
         // see if it has a declared type.
-        let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
+        let symbolWithScope = lookUpSymbolRecursive(node, name, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvalFlags.TypeExpression */) !== 0);
         if (!symbolWithScope) {
             // If the node is part of a "from X import Y as Z" statement and the node
             // is the "Y" (non-aliased) name, we need to look up the alias symbol
             // since the non-aliased name is not in the symbol table.
             const alias = getAliasFromImport(node);
             if (alias) {
-                symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0);
+                symbolWithScope = lookUpSymbolRecursive(alias, alias.value, !allowForwardReferences, allowForwardReferences && (flags & 256 /* EvalFlags.TypeExpression */) !== 0);
             }
         }
         if (symbolWithScope) {
@@ -3059,7 +3059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                     targetSymbolId: symbol.id,
                     typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
-                    skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
+                    skipConditionalNarrowing: (flags & 256 /* EvalFlags.TypeExpression */) !== 0,
                 });
                 if (codeFlowTypeResult.type) {
                     type = codeFlowTypeResult.type;
@@ -3070,32 +3070,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Detect, report, and fill in missing type arguments if appropriate.
             type = reportMissingTypeArguments(node, type, flags);
-            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                // Verify that the name does not refer to a (non type alias) variable.
-                if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
-                    let isAllowedTypeForVariable = (0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type);
-                    if ((0, types_1.isClass)(type) &&
-                        !type.includeSubclasses &&
-                        !symbol.hasTypedDeclarations() &&
-                        types_1.ClassType.isValidTypeAliasClass(type)) {
-                        // This check exempts class types that are created by calling
-                        // NewType, NamedTuple, etc.
-                        isAllowedTypeForVariable = true;
-                    }
-                    // Disable for assignments in the typings.pyi file, since it defines special forms.
-                    if (!isAllowedTypeForVariable && !fileInfo.isTypingStubFile) {
-                        // This might be a union that was previously a type alias
-                        // but was reconstituted in such a way that we lost the
-                        // typeAliasInfo. Avoid the false positive error by suppressing
-                        // the error when it looks like a plausible type alias type.
-                        if (effectiveTypeInfo.includesIllegalTypeAliasDecl ||
-                            !types_1.TypeBase.isInstantiable(type) ||
-                            (flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
-                            type = types_1.UnknownType.create();
-                        }
-                    }
-                }
+            // Report inappropriate use of variables in type expressions.
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                type = validateSymbolIsTypeExpression(node, type, !!effectiveTypeInfo.includesVariableDecl);
             }
         }
         else {
@@ -3109,17 +3086,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if ((0, types_1.isParamSpec)(type)) {
-            if (flags & 32 /* EvaluatorFlags.DisallowParamSpec */) {
+            if (flags & 32 /* EvalFlags.NoParamSpec */) {
                 addError(localize_1.LocMessage.paramSpecContext(), node);
                 type = types_1.UnknownType.create();
             }
         }
-        type = convertTypeVarToRuntimeInstance(node, type, flags);
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
+        type = convertSpecialFormToRuntimeValue(type, flags);
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
-        if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
-            if ((flags & 1024 /* EvaluatorFlags.AllowGenericClassType */) === 0) {
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
+            if ((flags & 1024 /* EvalFlags.AllowGeneric */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericNotAllowed(), node);
                 }
@@ -3130,26 +3107,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { type, isIncomplete };
     }
-    // If the type is a TypeVar and we're not expecting a type, convert
-    // a TypeVar, TypeVarTuple or ParamSpec into a runtime type.
-    function convertTypeVarToRuntimeInstance(node, type, flags) {
-        var _a;
-        if (!type.specialForm || type.typeAliasInfo) {
+    // Reports diagnostics if type isn't valid within a type expression.
+    function validateSymbolIsTypeExpression(node, type, includesVariableDecl) {
+        // Verify that the name does not refer to a (non type alias) variable.
+        if (!includesVariableDecl || type.typeAliasInfo) {
+            return type;
+        }
+        if ((0, types_1.isTypeVar)(type) || (0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
+            return type;
+        }
+        // Exempts class types that are created by calling
+        // NewType, NamedTuple, etc.
+        if ((0, types_1.isClass)(type) && !type.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
             return type;
         }
-        if (!(0, types_1.isTypeVar)(type) || type.isVariadicInUnion || (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
+        // Disable for assignments in the typings.pyi file, since it defines special forms.
+        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        if (fileInfo.isTypingStubFile) {
             return type;
         }
-        if ((flags & 33554432 /* EvaluatorFlags.SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
-            return types_1.TypeBase.cloneAsSpecialForm(type, undefined);
+        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), node);
+        return types_1.UnknownType.create();
+    }
+    // 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) {
+        var _a;
+        const exemptFlags = 256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
+        if ((flags & exemptFlags) !== 0) {
+            return type;
         }
-        // Handle the special case of a PEP 604 union. These can appear within
-        // an implied type alias where we are not expecting a type.
-        const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* ParseNodeType.BinaryOperation */ && node.parent.operator === 6 /* OperatorType.BitwiseOr */;
-        if (isPep604Union) {
-            return types_1.TypeBase.cloneAsSpecialForm(type, undefined);
+        // Isinstance treats traditional (non-PEP 695) type aliases that are unions
+        // as tuples of classes rather than unions.
+        if ((flags & 536870912 /* EvalFlags.IsinstanceParam */) !== 0) {
+            if ((0, types_1.isUnion)(type) && type.typeAliasInfo && !type.typeAliasInfo.isPep695Syntax) {
+                return type;
+            }
         }
-        return types_1.ClassType.cloneAsInstance(type.specialForm);
+        return (_a = type.specialForm) !== null && _a !== void 0 ? _a : type;
     }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (a function, lambda, or comprehension).
@@ -3235,7 +3231,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (types_1.TypeBase.isInstantiable(type) && !type.scopeId && !(0, typeUtils_1.isTypeAliasPlaceholder)(type)) {
             const scopedTypeVarInfo = findScopedTypeVar(node, type);
             type = scopedTypeVarInfo.type;
-            if ((flags & 2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */) !== 0 && type.scopeId !== undefined) {
+            if ((flags & 2048 /* EvalFlags.NoTypeVarWithScopeId */) !== 0 && type.scopeId !== undefined) {
                 if (!type.details.isSynthesized && !type.details.isParamSpec) {
                     // This TypeVar already has a scope ID assigned to it. See if it
                     // originates from type parameter syntax. If so, allow it.
@@ -3254,7 +3250,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: type.details.name }), node);
                 }
             }
-            else if ((flags & 8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */) !== 0) {
+            else if ((flags & 8192 /* EvalFlags.TypeVarGetsCurScope */) !== 0) {
                 if (type.scopeId === undefined) {
                     if (!scopedTypeVarInfo.foundInterveningClass) {
                         let enclosingScope = ParseTreeUtils.getEnclosingClassOrFunction(node);
@@ -3298,7 +3294,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            else if ((flags & 4096 /* EvaluatorFlags.AllowTypeVarsWithoutScopeId */) === 0) {
+            else if ((flags & 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */) === 0) {
                 if ((type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized) {
                     const message = (0, types_1.isParamSpec)(type)
@@ -3320,13 +3316,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // and optionally reports an error.
     function reportMissingTypeArguments(node, type, flags) {
         var _a;
-        if ((flags & 2 /* EvaluatorFlags.DoNotSpecialize */) !== 0) {
+        if ((flags & 2 /* EvalFlags.NoSpecialize */) !== 0) {
             return type;
         }
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
-            if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
-                (flags & 512 /* EvaluatorFlags.AllowMissingTypeArgs */) === 0) {
+            if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && (flags & 512 /* EvalFlags.AllowMissingTypeArgs */) === 0) {
                 if (!type.typeAliasInfo && (0, typeUtils_1.requiresTypeArguments)(type)) {
                     if (!type.typeArguments || !type.isTypeArgumentExplicit) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForClass().format({
@@ -3340,7 +3335,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Is this a generic type alias that needs to be specialized?
-        if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 &&
             type.typeAliasInfo &&
             type.typeAliasInfo.typeParameters &&
             type.typeAliasInfo.typeParameters.length > 0 &&
@@ -3354,7 +3349,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 let defaultType;
                 if (param.details.isDefaultExplicit || param.details.isParamSpec) {
-                    defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
+                    defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, {
+                        unknownIfNotFound: true,
+                        tupleClassType: getTupleClassType(),
+                    });
                 }
                 else if (param.details.isVariadic && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
                     defaultType = makeTupleObject([{ type: types_1.UnknownType.create(), isUnbounded: true }], 
@@ -3371,7 +3369,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     name: type.typeAliasInfo.name,
                 }), node);
             }
-            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, { unknownIfNotFound: true }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
+            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, {
+                unknownIfNotFound: true,
+                tupleClassType: getTupleClassType(),
+            }), type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, defaultTypeArgs);
         }
         return type;
     }
@@ -3426,11 +3427,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let leftType;
             let typeAliasNode = undefined;
             if (curNode.nodeType === 77 /* ParseNodeType.TypeAlias */) {
-                leftType = readTypeCache(curNode.name, 0 /* EvaluatorFlags.None */);
+                leftType = readTypeCache(curNode.name, 0 /* EvalFlags.None */);
                 typeAliasNode = curNode;
             }
             else if (curNode.nodeType === 3 /* ParseNodeType.Assignment */) {
-                leftType = readTypeCache(curNode.leftExpression, 0 /* EvaluatorFlags.None */);
+                leftType = readTypeCache(curNode.leftExpression, 0 /* EvalFlags.None */);
             }
             if (leftType) {
                 // Is this a placeholder that was temporarily written to the cache for
@@ -3472,20 +3473,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfMemberAccess(node, flags) {
         var _a;
         // Compute flags specifically for evaluating the left expression.
-        let leftExprFlags = 2 /* EvaluatorFlags.MemberAccessBaseDefaults */;
+        let leftExprFlags = 2 /* EvalFlags.MemberAccessBaseDefaults */;
         leftExprFlags |=
             flags &
-                (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-                    32768 /* EvaluatorFlags.VariableTypeAnnotation */ |
-                    4 /* EvaluatorFlags.AllowForwardReferences */ |
-                    524288 /* EvaluatorFlags.NotParsedByInterpreter */ |
-                    2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */ |
-                    8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */);
+                (256 /* EvalFlags.TypeExpression */ |
+                    32768 /* EvalFlags.VarTypeAnnotation */ |
+                    4 /* EvalFlags.ForwardRefs */ |
+                    524288 /* EvalFlags.NotParsed */ |
+                    2048 /* EvalFlags.NoTypeVarWithScopeId */ |
+                    8192 /* EvalFlags.TypeVarGetsCurScope */);
         // Handle special casing for ParamSpec "args" and "kwargs" accesses.
-        if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0) {
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
             const memberName = node.memberName.value;
             if (memberName === 'args' || memberName === 'kwargs') {
-                leftExprFlags |= 33554432 /* EvaluatorFlags.SkipConvertParamSpecToRuntimeObject */;
+                leftExprFlags |= 33554432 /* EvalFlags.NoConvertSpecialForm */;
             }
         }
         const baseTypeResult = getTypeOfExpression(node.leftExpression, leftExprFlags);
@@ -3495,7 +3496,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isIncomplete: true,
             };
         }
-        const typeResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, flags | 2 /* EvaluatorFlags.DoNotSpecialize */);
+        const typeResult = getTypeOfMemberAccessWithBaseType(node, baseTypeResult, { method: 'get' }, flags | 2 /* EvalFlags.NoSpecialize */);
         if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
             // Before performing code flow analysis, update the cache to prevent recursion.
             writeTypeCache(node, { ...typeResult, isIncomplete: true }, flags);
@@ -3522,7 +3523,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                 targetSymbolId: symbol_1.indeterminateSymbolId,
                 typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
-                skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
+                skipConditionalNarrowing: (flags & 256 /* EvalFlags.TypeExpression */) !== 0,
             });
             if (codeFlowTypeResult.type) {
                 typeResult.type = codeFlowTypeResult.type;
@@ -3577,7 +3578,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (baseTypeResult.isIncomplete && (0, types_1.isUnbound)(baseType)) {
             return { type: types_1.UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
-        if (baseType.specialForm) {
+        if (baseType.specialForm && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             baseType = baseType.specialForm;
         }
         if ((0, types_1.isParamSpec)(baseType) && baseType.paramSpecAccess) {
@@ -3618,7 +3619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     break;
                 }
                 // It's illegal to reference a member from a type variable.
-                if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                     if (!isIncomplete) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarNoMember().format({
                             type: printType(baseType),
@@ -3640,7 +3641,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type: makeTopLevelTypeVarsConcrete(baseType),
                     bindToSelfType: types_1.TypeBase.isInstantiable(baseType) ? (0, typeUtils_1.convertToInstance)(baseType) : baseType,
                     isIncomplete,
-                }, usage, 0 /* EvaluatorFlags.None */);
+                }, usage, 0 /* EvalFlags.None */);
             }
             case 6 /* TypeCategory.Class */: {
                 let typeResult;
@@ -3660,8 +3661,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 if (!typeResult) {
-                    typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, 
-                    /* memberAccessFlags */ undefined, baseTypeResult.bindToSelfType);
+                    typeResult = getTypeOfBoundMember(node.memberName, baseType, memberName, usage, diag, (flags & 256 /* EvalFlags.TypeExpression */) === 0 ? undefined : 2048 /* MemberAccessFlags.TypeExpression */, baseTypeResult.bindToSelfType);
                 }
                 if (typeResult) {
                     if (!typeResult.typeErrors) {
@@ -3693,9 +3693,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (usage.method === 'get') {
                         setSymbolAccessed(fileInfo, symbol, node.memberName);
                     }
-                    type = getEffectiveTypeOfSymbolForUsage(symbol, 
+                    const typeResult = getEffectiveTypeOfSymbolForUsage(symbol, 
                     /* usageNode */ undefined, 
-                    /* useLastDecl */ true).type;
+                    /* useLastDecl */ true);
+                    type = typeResult.type;
+                    if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                        type = validateSymbolIsTypeExpression(node, type, !!typeResult.includesVariableDecl);
+                    }
                     if ((0, types_1.isTypeVar)(type)) {
                         type = validateTypeVarUsage(node, type, flags);
                     }
@@ -3778,7 +3782,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const typeResult = getTypeOfMemberAccessWithBaseType(node, {
                         type: subtype,
                         isIncomplete: baseTypeResult.isIncomplete,
-                    }, usage, 0 /* EvaluatorFlags.None */);
+                    }, usage, 0 /* EvalFlags.None */);
                     if (typeResult.isIncomplete) {
                         isIncomplete = true;
                     }
@@ -3851,9 +3855,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // additional reportUnknownMemberType diagnostics.
             type = isFunctionRule ? types_1.AnyType.create() : types_1.UnknownType.create();
         }
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             reportUseOfTypeCheckOnly(type, node.memberName);
         }
+        type = convertSpecialFormToRuntimeValue(type, flags);
         return {
             type,
             isIncomplete,
@@ -4448,22 +4453,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isAsymmetricAccessor,
         };
     }
-    function getTypeOfIndex(node, flags = 0 /* EvaluatorFlags.None */) {
-        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* EvaluatorFlags.IndexBaseDefaults */);
+    function getTypeOfIndex(node, flags = 0 /* EvalFlags.None */) {
+        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 2 /* EvalFlags.IndexBaseDefaults */);
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this is an illegal annotation form and will generate a
         // runtime exception.
-        if (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) {
+        if (flags & 128 /* EvalFlags.InstantiableType */) {
             if (node.baseExpression.nodeType === 48 /* ParseNodeType.StringList */) {
                 addError(localize_1.LocMessage.stringNotSubscriptable(), node.baseExpression);
             }
         }
         // Check for builtin classes that will generate runtime exceptions if subscripted.
-        if ((flags & 4 /* EvaluatorFlags.AllowForwardReferences */) === 0) {
+        if ((flags & 4 /* EvalFlags.ForwardRefs */) === 0) {
             // We can skip this check if the class is used within a PEP 526 variable
             // type annotation within a class or function. For some undocumented reason,
             // they don't result in runtime exceptions when used in this manner.
-            let skipSubscriptCheck = (flags & 32768 /* EvaluatorFlags.VariableTypeAnnotation */) !== 0;
+            let skipSubscriptCheck = (flags & 32768 /* EvalFlags.VarTypeAnnotation */) !== 0;
             if (skipSubscriptCheck) {
                 const scopeNode = ParseTreeUtils.getExecutionScopeNode(node);
                 if ((scopeNode === null || scopeNode === void 0 ? void 0 : scopeNode.nodeType) === 36 /* ParseNodeType.Module */) {
@@ -4509,7 +4514,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         type: indexTypeResult.type,
                         isIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
                     },
-                    skipConditionalNarrowing: (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0,
+                    skipConditionalNarrowing: (flags & 256 /* EvalFlags.TypeExpression */) !== 0,
                 });
                 if (codeFlowTypeResult.type) {
                     indexTypeResult.type = codeFlowTypeResult.type;
@@ -4772,12 +4777,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
                 }
                 else if (param.details.isDefaultExplicit) {
-                    typeArgType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, { unknownIfNotFound: true });
+                    typeArgType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, {
+                        unknownIfNotFound: true,
+                        tupleClassType: getTupleClassType(),
+                    });
                 }
                 else {
                     typeArgType = types_1.UnknownType.create();
                 }
-                if ((flags & 16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */) !== 0) {
+                if ((flags & 16384 /* EvalFlags.EnforceVarianceConsistency */) !== 0) {
                     const usageVariances = inferTypeParameterVarianceForTypeAlias(baseType);
                     if (usageVariances && index < usageVariances.length) {
                         const usageVariance = usageVariances[index];
@@ -4847,9 +4855,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             var _a;
             const selfType = (0, types_1.isTypeVar)(unexpandedSubtype) ? unexpandedSubtype : undefined;
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    // If we are expecting a type annotation here, assume that
+                    // the subscripts are type arguments and evaluate them
+                    // accordingly.
+                    getTypeArgs(node, flags);
+                }
                 return concreteSubtype;
             }
-            if (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) {
+            if (flags & 128 /* EvalFlags.InstantiableType */) {
                 if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarNotSubscriptable().format({
                         type: printType(unexpandedSubtype),
@@ -4864,9 +4878,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
                     !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
-                    (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) === 0) {
+                    (flags & 128 /* EvalFlags.InstantiableType */) === 0) {
                     const itemMethodType = getBoundMagicMethod(concreteSubtype, getIndexAccessMagicMethodName(usage));
-                    if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+                    if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                         // If the class doesn't derive from Generic, a type argument should not be allowed.
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                             name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
@@ -4891,8 +4905,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
                     // Special-case InitVar, used in dataclasses.
                     const typeArgs = getTypeArgs(node, flags);
-                    if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
-                        if ((flags & 32768 /* EvaluatorFlags.VariableTypeAnnotation */) === 0) {
+                    if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                        if ((flags & 32768 /* EvalFlags.VarTypeAnnotation */) === 0) {
                             addError(localize_1.LocMessage.initVarNotAllowed(), node.baseExpression);
                         }
                     }
@@ -4981,7 +4995,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!baseTypeResult.isIncomplete) {
             node.items.forEach((item) => {
                 if (!isTypeCached(item.valueExpression)) {
-                    getTypeOfExpression(item.valueExpression, flags & 4 /* EvaluatorFlags.AllowForwardReferences */);
+                    getTypeOfExpression(item.valueExpression, flags & 4 /* EvalFlags.ForwardRefs */);
                 }
             });
         }
@@ -5284,10 +5298,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const typeArgs = [];
         let adjFlags = flags;
         if (options === null || options === void 0 ? void 0 : options.isFinalAnnotation) {
-            adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */ | 16 /* EvaluatorFlags.DisallowFinal */;
+            adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
         }
         else if (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation) {
-            adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */;
+            adjFlags |= 131072 /* EvalFlags.NoClassVar */;
             // If the annotation is a variable within the body of a dataclass, a
             // Final is allowed within the ClassVar annotation. In all other cases,
             // it's disallowed.
@@ -5300,19 +5314,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (disallowFinal) {
-                adjFlags |= 16 /* EvaluatorFlags.DisallowFinal */;
+                adjFlags |= 16 /* EvalFlags.NoFinal */;
             }
         }
         else {
-            adjFlags &= ~(2 /* EvaluatorFlags.DoNotSpecialize */ |
-                32 /* EvaluatorFlags.DisallowParamSpec */ |
-                64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                1048576 /* EvaluatorFlags.AllowRequired */ |
-                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */);
+            adjFlags &= ~(2 /* EvalFlags.NoSpecialize */ |
+                32 /* EvalFlags.NoParamSpec */ |
+                64 /* EvalFlags.NoTypeVarTuple */ |
+                1048576 /* EvalFlags.AllowRequired */ |
+                16384 /* EvalFlags.EnforceVarianceConsistency */);
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
-                adjFlags |= 131072 /* EvaluatorFlags.DisallowClassVar */ | 16 /* EvaluatorFlags.DisallowFinal */;
+                adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
             }
-            adjFlags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */ | 134217728 /* EvaluatorFlags.AllowConcatenate */;
+            adjFlags |= 2097152 /* EvalFlags.AllowUnpackedTuple */ | 134217728 /* EvalFlags.AllowConcatenate */;
         }
         // Create a local function that validates a single type argument.
         const getTypeArgTypeResult = (expr, argIndex) => {
@@ -5321,10 +5335,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // treated as types.
             if (options === null || options === void 0 ? void 0 : options.hasCustomClassGetItem) {
                 adjFlags =
-                    32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        2 /* EvaluatorFlags.DoNotSpecialize */ |
-                        131072 /* EvaluatorFlags.DisallowClassVar */;
+                    32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
                 typeResult = {
                     ...getTypeOfExpression(expr, adjFlags),
                     node: expr,
@@ -5334,12 +5345,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If it's an Annotated[a, b, c], only the first index should be
                 // treated as a type.The others can be regular(non - type) objects.
                 adjFlags =
-                    32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        2 /* EvaluatorFlags.DoNotSpecialize */ |
-                        131072 /* EvaluatorFlags.DisallowClassVar */;
+                    32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
                 if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
-                    adjFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
+                    adjFlags |= 4 /* EvalFlags.ForwardRefs */;
                 }
                 typeResult = {
                     ...getTypeOfExpression(expr, adjFlags),
@@ -5393,13 +5401,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeArg(node, flags) {
         let typeResult;
-        let adjustedFlags = flags |
-            128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-            1 /* EvaluatorFlags.ConvertEllipsisToAny */ |
-            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */;
+        let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile) {
-            adjustedFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
+            adjustedFlags |= 4 /* EvalFlags.ForwardRefs */;
         }
         if (node.nodeType === 34 /* ParseNodeType.List */) {
             typeResult = {
@@ -5417,7 +5422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
                 addError(localize_1.LocMessage.dictInAnnotation(), node);
             }
-            if ((flags & 131072 /* EvaluatorFlags.DisallowClassVar */) !== 0) {
+            if ((flags & 131072 /* EvalFlags.NoClassVar */) !== 0) {
                 // "ClassVar" is not allowed as a type argument.
                 if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
                     addError(localize_1.LocMessage.classVarNotAllowed(), node);
@@ -5428,8 +5433,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfTuple(node, flags, inferenceContext, signatureTracker) {
         var _a;
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
-            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             // This is allowed inside of an index trailer, specifically
             // to support Tuple[()], which is the documented way to annotate
             // a zero-length tuple.
@@ -5438,14 +5442,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.tupleInAnnotation() + diag.getString(), node);
             return { type: types_1.UnknownType.create() };
         }
-        if ((flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0 &&
-            node.expressions.length === 0 &&
-            !inferenceContext) {
+        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && node.expressions.length === 0 && !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
-        flags &= ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-            128 /* EvaluatorFlags.ExpectingInstantiableType */);
+        flags &= ~(256 /* EvalFlags.TypeExpression */ | 8 /* EvalFlags.StrLiteralAsType */ | 128 /* EvalFlags.InstantiableType */);
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -5511,7 +5511,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClass));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
             const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClass, tupleTypeVarContext);
@@ -5523,7 +5523,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expectedTypes.push(homogenousType);
             }
         }
-        const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete), signatureTracker));
+        const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete), signatureTracker));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = makeTupleObject(buildTupleTypesList(entryTypeResults, /* stripLiterals */ false));
         // Copy any expected type diag addenda for precision error reporting.
@@ -5539,9 +5539,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return { type, expectedTypeDiagAddendum, isIncomplete };
     }
     function getTypeOfTupleInferred(node, flags) {
-        const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */));
+        const entryTypeResults = node.expressions.map((expr) => getTypeOfExpression(expr, flags | 268435456 /* EvalFlags.StripTupleLiterals */));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
-        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */) !== 0));
+        const type = makeTupleObject(buildTupleTypesList(entryTypeResults, (flags & 268435456 /* EvalFlags.StripTupleLiterals */) !== 0));
         if (isIncomplete) {
             if ((0, typeUtils_1.getContainerDepth)(type) > maxInferredContainerDepth) {
                 return { type: types_1.UnknownType.create() };
@@ -5598,7 +5598,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Check for the use of `type(x)` within a type annotation. This isn't
         // allowed, and it's a common mistake, so we want to emit a diagnostic
         // that guides the user to the right solution.
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 &&
             node.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
             node.leftExpression.value === 'type') {
             const diag = new diagnostic_1.DiagnosticAddendum();
@@ -5610,7 +5610,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
         }
         else {
-            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */ | (flags & 4 /* EvaluatorFlags.AllowForwardReferences */));
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* EvalFlags.CallBaseDefaults */ | (flags & 4 /* EvalFlags.ForwardRefs */));
         }
         const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
@@ -5702,7 +5702,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
             }
         }
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationCall(), node);
             typeResult = { type: types_1.UnknownType.create() };
         }
@@ -5741,7 +5741,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         function getLambdaType() {
-            return getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+            return getTypeOfExpression(node.leftExpression, 2 /* EvalFlags.CallBaseDefaults */, (0, typeUtils_1.makeInferenceContext)(expectedType));
         }
         // If one or more of the arguments are incomplete, use speculative mode
         // for the lambda evaluation because it may need to be reevaluated once
@@ -5751,7 +5751,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             : getLambdaType();
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+            typeResult = getTypeOfExpression(node.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
         }
         return typeResult;
     }
@@ -5904,7 +5904,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     /* isInClass */ true);
                     if (((functionInfo === null || functionInfo === void 0 ? void 0 : functionInfo.flags) & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
                         addError(localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.leftExpression);
-                        targetClassType = types_1.UnknownType.create();
                     }
                 }
             }
@@ -5913,6 +5912,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 targetClassType = types_1.UnknownType.create();
             }
         }
+        const concreteTargetClassType = makeTopLevelTypeVarsConcrete(targetClassType);
         // Determine whether to further narrow the type.
         let bindToType;
         if (node.arguments.length > 1) {
@@ -5922,8 +5922,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Ignore unknown or any types.
             }
             else if ((0, types_1.isClassInstance)(secondArgType)) {
-                if ((0, types_1.isInstantiableClass)(targetClassType)) {
-                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgType), targetClassType, 
+                if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                    if (!(0, typeUtils_1.derivesFromClassRecursive)(types_1.ClassType.cloneAsInstantiable(secondArgType), concreteTargetClassType, 
                     /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
@@ -5931,9 +5931,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 bindToType = secondArgType;
             }
             else if ((0, types_1.isInstantiableClass)(secondArgType)) {
-                if ((0, types_1.isInstantiableClass)(targetClassType)) {
-                    if (!types_1.ClassType.isBuiltIn(targetClassType, 'type') &&
-                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, targetClassType, /* ignoreUnknown */ true)) {
+                if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
+                    if (!types_1.ClassType.isBuiltIn(concreteTargetClassType, 'type') &&
+                        !(0, typeUtils_1.derivesFromClassRecursive)(secondArgType, concreteTargetClassType, /* ignoreUnknown */ true)) {
                         reportError = true;
                     }
                 }
@@ -5999,7 +5999,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const parentNode = node.parent;
         if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) === 35 /* ParseNodeType.MemberAccess */) {
             const memberName = parentNode.memberName.value;
-            let effectiveTargetClass = (0, types_1.isClass)(targetClassType) ? targetClassType : undefined;
+            let effectiveTargetClass = (0, types_1.isClass)(concreteTargetClassType) ? concreteTargetClassType : undefined;
             // If the bind-to type is a protocol, don't use the effective target class.
             // This pattern is used for mixins, where the mixin type is a protocol class
             // that is used to decorate the "self" or "cls" parameter.
@@ -6040,7 +6040,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             };
         }
         // Handle the super() call when used outside of a member access expression.
-        if ((0, types_1.isInstantiableClass)(targetClassType)) {
+        if ((0, types_1.isInstantiableClass)(concreteTargetClassType)) {
             // We don't know which member is going to be accessed, so we cannot
             // deterministically determine the correct type in this case. We'll
             // use a heuristic that produces the "correct" (desired) behavior in
@@ -6049,13 +6049,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // class.
             if (bindToType) {
                 let nextBaseClassType;
-                if (types_1.ClassType.isSameGenericClass(bindToType, targetClassType)) {
+                if (types_1.ClassType.isSameGenericClass(bindToType, concreteTargetClassType)) {
                     if (bindToType.details.baseClasses.length > 0) {
                         nextBaseClassType = bindToType.details.baseClasses[0];
                     }
                 }
                 else {
-                    const baseClassIndex = bindToType.details.baseClasses.findIndex((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isSameGenericClass(baseClass, targetClassType));
+                    const baseClassIndex = bindToType.details.baseClasses.findIndex((baseClass) => (0, types_1.isClass)(baseClass) &&
+                        types_1.ClassType.isSameGenericClass(baseClass, concreteTargetClassType));
                     if (baseClassIndex >= 0 && baseClassIndex < bindToType.details.baseClasses.length - 1) {
                         nextBaseClassType = bindToType.details.baseClasses[baseClassIndex + 1];
                     }
@@ -6076,10 +6077,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 // If the class derives from one or more unknown classes,
                 // return unknown here to prevent spurious errors.
-                if (targetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
+                if (concreteTargetClassType.details.mro.some((mroBase) => (0, types_1.isAnyOrUnknown)(mroBase))) {
                     return { type: types_1.UnknownType.create() };
                 }
-                const baseClasses = targetClassType.details.baseClasses;
+                const baseClasses = concreteTargetClassType.details.baseClasses;
                 if (baseClasses.length > 0) {
                     const baseClassType = baseClasses[0];
                     if ((0, types_1.isInstantiableClass)(baseClassType)) {
@@ -7480,7 +7481,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* ArgumentCategory.UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker).type;
+                    const argTypeResult = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType), signatureTracker);
+                    const argType = argTypeResult.type;
+                    if (argTypeResult.isIncomplete) {
+                        isTypeIncomplete = true;
+                    }
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
                     }
@@ -7651,21 +7656,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         else if (paramDetails.kwargsIndex !== undefined) {
                             const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
-                            validateArgTypeParams.push({
-                                paramCategory: 2 /* ParameterCategory.KwargsDict */,
-                                paramType,
-                                requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
-                                argument: argList[argIndex],
-                                errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
-                                paramName: paramNameValue,
-                            });
-                            // Remember that this parameter has already received a value.
-                            paramMap.set(paramNameValue, {
-                                argsNeeded: 1,
-                                argsReceived: 1,
-                                isPositionalOnly: false,
-                            });
-                            (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], 'paramDetails.kwargsIndex params entry is undefined');
+                            if ((0, types_1.isParamSpec)(paramType)) {
+                                if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.paramNameMissing().format({ name: paramName.value }), paramName);
+                                }
+                                reportedArgError = true;
+                            }
+                            else {
+                                validateArgTypeParams.push({
+                                    paramCategory: 2 /* ParameterCategory.KwargsDict */,
+                                    paramType,
+                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
+                                    argument: argList[argIndex],
+                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
+                                    paramName: paramNameValue,
+                                });
+                                // Remember that this parameter has already received a value.
+                                paramMap.set(paramNameValue, {
+                                    argsNeeded: 1,
+                                    argsReceived: 1,
+                                    isPositionalOnly: false,
+                                });
+                                (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], 'paramDetails.kwargsIndex params entry is undefined');
+                            }
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
                         else {
@@ -7968,12 +7981,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
+                    if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
                         const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                         /* typeArguments */ undefined, 
                         /* isTypeArgumentExplicit */ false);
                         effectiveExpectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
                             unknownIfNotFound: true,
+                            tupleClassType: getTupleClassType(),
                         });
                         effectiveFlags |= 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
                     }
@@ -8191,6 +8205,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const unknownIfNotFound = !ParseTreeUtils.getTypeVarScopesForNode(errorNode).some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope));
         let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
             unknownIfNotFound,
+            tupleClassType: getTupleClassType(),
             unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
             eliminateUnsolvedInUnions,
             applyInScopePlaceholders: true,
@@ -8202,6 +8217,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             paramSpecTypeVarContext.forEach((paramSpecTypeVarContext) => {
                 if (paramSpecTypeVarContext) {
                     specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(specializedReturnType, paramSpecTypeVarContext);
+                    // It's possible that one or more of the TypeVars or ParamSpecs
+                    // in the typeVarContext refer to TypeVars that were solved in
+                    // the paramSpecTypeVarContext. Apply these solved TypeVars accordingly.
+                    (0, typeUtils_1.applySourceContextTypeVars)(typeVarContext, paramSpecTypeVarContext);
                 }
             });
         }
@@ -8468,13 +8487,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 const flags = argParam.isinstanceParam
-                    ? 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
-                        8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                        32 /* EvaluatorFlags.DisallowParamSpec */ |
-                        64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                        16 /* EvaluatorFlags.DisallowFinal */ |
-                        2 /* EvaluatorFlags.DoNotSpecialize */
-                    : 2 /* EvaluatorFlags.DoNotSpecialize */ | 16 /* EvaluatorFlags.DisallowFinal */;
+                    ? 512 /* EvalFlags.AllowMissingTypeArgs */ |
+                        8 /* EvalFlags.StrLiteralAsType */ |
+                        32 /* EvalFlags.NoParamSpec */ |
+                        64 /* EvalFlags.NoTypeVarTuple */ |
+                        16 /* EvalFlags.NoFinal */ |
+                        2 /* EvalFlags.NoSpecialize */ |
+                        536870912 /* EvalFlags.IsinstanceParam */
+                    : 16 /* EvalFlags.NoFinal */ | 2 /* EvalFlags.NoSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)), signatureTracker);
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
@@ -8501,7 +8521,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 expectedTypeDiag = exprTypeResult.expectedTypeDiagAddendum;
             }
             if (argParam.argument && argParam.argument.name && !isSpeculativeModeInUse(argParam.errorNode)) {
-                writeTypeCache(argParam.argument.name, { type: expectedType !== null && expectedType !== void 0 ? expectedType : argType, isIncomplete: isTypeIncomplete }, 0 /* EvaluatorFlags.None */);
+                writeTypeCache(argParam.argument.name, { type: expectedType !== null && expectedType !== void 0 ? expectedType : argType, isIncomplete: isTypeIncomplete }, 0 /* EvalFlags.None */);
             }
         }
         else {
@@ -8819,6 +8839,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.scopeId);
         const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.details.defaultType, typeVarContext, {
             unknownIfNotFound: true,
+            tupleClassType: getTupleClassType(),
         }));
         if (typeVar.details.boundType) {
             if (!assignType(typeVar.details.boundType, concreteDefaultType)) {
@@ -9067,7 +9088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeParameters = [];
             let isTypeParamListValid = true;
             typeParamsExpr.expressions.map((expr) => {
-                let entryType = getTypeOfExpression(expr, 128 /* EvaluatorFlags.ExpectingInstantiableType */ | 4096 /* EvaluatorFlags.AllowTypeVarsWithoutScopeId */).type;
+                let entryType = getTypeOfExpression(expr, 128 /* EvalFlags.InstantiableType */ | 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
                     if (entryType.scopeId || entryType.isVariadicUnpacked) {
                         isTypeParamListValid = false;
@@ -9166,9 +9187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else if (baseClass.literalValue !== undefined) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.newTypeLiteral(), argList[1].node || errorNode);
         }
-        let classFlags = baseClass.details.flags & ~(1 /* ClassTypeFlags.BuiltInClass */ | 2 /* ClassTypeFlags.SpecialBuiltIn */);
-        classFlags |= 256 /* ClassTypeFlags.Final */ | 2097152 /* ClassTypeFlags.NewTypeClass */ | 4194304 /* ClassTypeFlags.ValidTypeAliasClass */;
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(errorNode), 
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 256 /* ClassTypeFlags.Final */ | 2097152 /* ClassTypeFlags.NewTypeClass */ | 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), 
         /* declaredMetaclass */ undefined, baseClass.details.effectiveMetaclass);
         classType.details.baseClasses.push(isBaseClassAny ? types_1.AnyType.create() : baseClass);
         (0, typeUtils_1.computeMroLinearization)(classType);
@@ -9240,10 +9259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let type;
         if (node.constType === 26 /* KeywordType.None */) {
             if (noneTypeClass) {
-                type =
-                    (flags & 128 /* EvaluatorFlags.ExpectingInstantiableType */) !== 0
-                        ? noneTypeClass
-                        : (0, typeUtils_1.convertToInstance)(noneTypeClass);
+                type = (flags & 128 /* EvalFlags.InstantiableType */) !== 0 ? noneTypeClass : (0, typeUtils_1.convertToInstance)(noneTypeClass);
             }
         }
         else if (node.constType === 33 /* KeywordType.True */ ||
@@ -9336,8 +9352,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfDictionary(node, flags, inferenceContext) {
         var _a;
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
-            ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useDictInstead());
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.dictInAnnotation() + diag.getString(), node);
@@ -9376,7 +9391,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return result;
             }
         }
-        const result = getTypeOfDictionaryInferred(node, flags, /* hasExpectedType */ !!inferenceContext);
+        const result = getTypeOfDictionaryInferred(node, flags, /* hasExpectedType */ !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType));
         return { ...result, expectedTypeDiagAddendum };
     }
     function getTypeOfDictionaryWithContext(node, flags, inferenceContext, expectedDiagAddendum) {
@@ -9431,7 +9446,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return undefined;
             }
             const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
             const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
@@ -9532,16 +9547,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let typeErrors = false;
         // Mask out some of the flags that are not applicable for a dictionary key
         // even if it appears within an inlined TypedDict annotation.
-        const keyFlags = flags &
-            ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-                8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                128 /* EvaluatorFlags.ExpectingInstantiableType */);
+        const keyFlags = flags & ~(256 /* EvalFlags.TypeExpression */ | 8 /* EvalFlags.StrLiteralAsType */ | 128 /* EvalFlags.InstantiableType */);
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
             var _a, _b, _c;
             let addUnknown = true;
             if (entryNode.nodeType === 20 /* ParseNodeType.DictionaryKeyEntry */) {
-                const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, keyFlags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
+                const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, keyFlags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(expectedKeyType !== null && expectedKeyType !== void 0 ? expectedKeyType : (forceStrictInference ? types_1.NeverType.createNever() : undefined)));
                 if (keyTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -9564,12 +9576,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     expectedTypedDictEntries.knownItems.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.knownItems.get(keyType.literalValue).valueType;
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
-                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
+                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
-                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
+                    valueTypeResult = getTypeOfExpression(entryNode.valueExpression, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
                 }
                 if (entryInferenceContext && !valueTypeResult.typeErrors) {
                     const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !isValueTypeInvariant);
@@ -9611,7 +9623,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
-                let unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, entryInferenceContext);
+                let unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
                 if (entryInferenceContext && !unexpandedTypeResult.typeErrors) {
                     const fromExpectedType = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !isValueTypeInvariant);
                     if (fromExpectedType) {
@@ -9675,7 +9687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if (entryNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
-                const dictEntryTypeResult = getElementTypeFromComprehension(entryNode, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedValueType, expectedKeyType);
+                const dictEntryTypeResult = getElementTypeFromComprehension(entryNode, flags | 268435456 /* EvalFlags.StripTupleLiterals */, expectedValueType, expectedKeyType);
                 const dictEntryType = dictEntryTypeResult.type;
                 if (dictEntryTypeResult.isIncomplete) {
                     isIncomplete = true;
@@ -9706,16 +9718,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfListOrSet(node, flags, inferenceContext) {
         var _a;
-        if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0 &&
+        if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 &&
             node.nodeType === 34 /* ParseNodeType.List */ &&
             ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 1 /* ParseNodeType.Argument */) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             diag.addMessage(localize_1.LocAddendum.useListInstead());
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.listInAnnotation() + diag.getString(), node);
         }
-        flags &= ~(256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-            128 /* EvaluatorFlags.ExpectingInstantiableType */);
+        flags &= ~(256 /* EvalFlags.TypeExpression */ | 8 /* EvalFlags.StrLiteralAsType */ | 128 /* EvalFlags.InstantiableType */);
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
         let effectiveExpectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -9751,7 +9761,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             expectedTypeDiagAddendum = result === null || result === void 0 ? void 0 : result.expectedTypeDiagAddendum;
         }
         const typeResult = getTypeOfListOrSetInferred(node, flags, 
-        /* hasExpectedType */ inferenceContext !== undefined);
+        /* hasExpectedType */ !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType));
         return { ...typeResult, expectedTypeDiagAddendum };
     }
     // Attempts to determine the type of a list or set statement based on an expected type.
@@ -9771,10 +9781,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         node.entries.forEach((entry) => {
             let entryTypeResult;
             if (entry.nodeType === 11 /* ParseNodeType.Comprehension */) {
-                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedEntryType);
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */, expectedEntryType);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */, (0, typeUtils_1.makeInferenceContext)(expectedEntryType));
             }
             entryTypes.push(entryTypeResult.type);
             if (entryTypeResult.isIncomplete) {
@@ -9818,7 +9828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(expectedClassType));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(expectedClassType, typeVarContext);
@@ -9838,10 +9848,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         node.entries.forEach((entry, index) => {
             let entryTypeResult;
             if (entry.nodeType === 11 /* ParseNodeType.Comprehension */ && !entry.isGenerator) {
-                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */);
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
             }
             else {
-                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */);
+                entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
             }
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
@@ -9849,7 +9859,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (entryTypeResult.typeErrors) {
                 typeErrors = true;
             }
-            if (index < maxEntriesToUseForInference) {
+            if (hasExpectedType || index < maxEntriesToUseForInference) {
                 entryTypes.push(entryTypeResult.type);
             }
             if (verifyHashable && !entryTypeResult.isIncomplete && !entryTypeResult.typeErrors) {
@@ -10037,7 +10047,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
             // Pre-cache the incomplete function type in case the evaluation of the
             // lambda depends on itself.
-            writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* EvalFlags.None */);
             // We assume for simplicity that the parameter signature of the lambda is
             // the same as the expected type. If this isn't the case, we'll use
             // object for any lambda parameters that don't match. We could make this
@@ -10074,11 +10084,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     paramType = inferParameterTypeFromDefaultValue(param.defaultValue);
                 }
                 if (param.name) {
-                    writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* EvaluatorFlags.None */);
+                    writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* EvalFlags.None */);
                 }
                 if (param.defaultValue) {
                     // Evaluate the default value if it's present.
-                    getTypeOfExpression(param.defaultValue, 1 /* EvaluatorFlags.ConvertEllipsisToAny */);
+                    getTypeOfExpression(param.defaultValue, 1 /* EvalFlags.ConvertEllipsisToAny */);
                 }
                 // Determine whether we need to insert an implied position-only parameter.
                 // This is needed when a function's parameters are named using the old-style
@@ -10179,7 +10189,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const builtInIteratorType = getTypingType(node, isAsync ? 'AsyncGenerator' : 'Generator');
         const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
-        const elementTypeResult = getElementTypeFromComprehension(node, flags | 268435456 /* EvaluatorFlags.StripLiteralTypeForTuple */, expectedEntryType);
+        const elementTypeResult = getElementTypeFromComprehension(node, flags | 268435456 /* EvalFlags.StripTupleLiterals */, expectedEntryType);
         if (elementTypeResult.isIncomplete) {
             isIncomplete = true;
         }
@@ -10496,7 +10506,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 addError(localize_1.LocMessage.optionalExtraArgs(), errorNode);
                 return types_1.UnknownType.create();
             }
@@ -10510,10 +10520,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!validateTypeArg(typeArgs[0])) {
             typeArg0Type = types_1.UnknownType.create();
         }
-        else if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeArg0Type)) {
-            addExpectedClassDiagnostic(typeArg0Type, typeArgs[0].node);
-            typeArg0Type = types_1.UnknownType.create();
-        }
         let optionalType = (0, types_1.combineTypes)([typeArg0Type, noneTypeClass !== null && noneTypeClass !== void 0 ? noneTypeClass : types_1.UnknownType.create()]);
         if (unionTypeClass && (0, types_1.isInstantiableClass)(unionTypeClass)) {
             optionalType = types_1.TypeBase.cloneAsSpecialForm(optionalType, types_1.ClassType.cloneAsInstance(unionTypeClass));
@@ -10599,7 +10605,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (!type) {
-                const exprType = getTypeOfExpression(itemExpr, flags & 4 /* EvaluatorFlags.AllowForwardReferences */);
+                const exprType = getTypeOfExpression(itemExpr, (flags & 4 /* EvalFlags.ForwardRefs */) | 33554432 /* EvalFlags.NoConvertSpecialForm */ | 256 /* EvalFlags.TypeExpression */);
                 // Is this an enum type?
                 if ((0, types_1.isClassInstance)(exprType.type) &&
                     types_1.ClassType.isEnumClass(exprType.type) &&
@@ -10636,7 +10642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Creates a ClassVar type.
     function createClassVarType(classType, errorNode, typeArgs, flags) {
         var _a;
-        if (flags & 131072 /* EvaluatorFlags.DisallowClassVar */) {
+        if (flags & 131072 /* EvalFlags.NoClassVar */) {
             addError(localize_1.LocMessage.classVarNotAllowed(), errorNode);
             return types_1.AnyType.create();
         }
@@ -10668,7 +10674,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
         if (!typeArgs) {
-            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 addError(localize_1.LocMessage.typeGuardArgCount(), errorNode);
             }
             return classType;
@@ -10699,7 +10705,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
-            if ((flags & (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ | 128 /* EvaluatorFlags.ExpectingInstantiableType */)) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
             }
             return types_1.UnknownType.create();
@@ -10740,7 +10746,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
-        if (!typeArgs && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
+        if (!typeArgs && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
@@ -10764,7 +10770,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 isUsageLegal = true;
             }
         }
-        if ((flags & 1048576 /* EvaluatorFlags.AllowRequired */) !== 0) {
+        if ((flags & 1048576 /* EvalFlags.AllowRequired */) !== 0) {
             isUsageLegal = true;
         }
         let isReadOnly = typeArgs[0].isReadOnly;
@@ -10799,7 +10805,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
-        if (!typeArgs && (flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) === 0) {
+        if (!typeArgs && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             return classType;
         }
         if (!typeArgs || typeArgs.length !== 1) {
@@ -10810,7 +10816,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnion)(typeArgType) && typeArgType.subtypes.length === 1) {
             typeArgType = typeArgType.subtypes[0];
         }
-        if ((flags & 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */) !== 0) {
+        if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && !typeArgType.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
@@ -10820,7 +10826,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
             return types_1.UnknownType.create();
         }
-        if ((flags & 8388608 /* EvaluatorFlags.AllowUnpackedTypedDict */) !== 0) {
+        if ((flags & 4194304 /* EvalFlags.AllowUnpackedTypedDict */) !== 0) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isTypedDictClass(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
@@ -10832,7 +10838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
-        if (flags & 16 /* EvaluatorFlags.DisallowFinal */) {
+        if (flags & 16 /* EvalFlags.NoFinal */) {
             addError(localize_1.LocMessage.finalContext(), errorNode);
             return classType;
         }
@@ -10845,7 +10851,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return types_1.TypeBase.cloneAsSpecialForm(typeArgs[0].type, classType);
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
-        if ((flags & 134217728 /* EvaluatorFlags.AllowConcatenate */) === 0) {
+        if ((flags & 134217728 /* EvalFlags.AllowConcatenate */) === 0) {
             addError(localize_1.LocMessage.concatenateContext(), errorNode);
             return types_1.AnyType.create();
         }
@@ -10874,7 +10880,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return createSpecialType(classType, typeArgs, /* paramLimit */ undefined, /* allowParamSpec */ true);
     }
-    function createAnnotatedType(classType, errorNode, typeArgs) {
+    function createAnnotatedType(classType, errorNode, typeArgs, flags) {
+        const typeExprFlags = 256 /* EvalFlags.TypeExpression */ | 33554432 /* EvalFlags.NoConvertSpecialForm */;
+        if ((flags & typeExprFlags) === 0) {
+            return { type: classType };
+        }
         if (typeArgs) {
             if (typeArgs.length < 2) {
                 addError(localize_1.LocMessage.annotatedTypeArgMissing(), errorNode);
@@ -11060,7 +11070,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 256 /* EvaluatorFlags.ExpectingTypeAnnotation */) !== 0) {
+            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
                 addError(localize_1.LocMessage.unionTypeArgCount(), errorNode);
                 return types_1.NeverType.createNever();
             }
@@ -11074,10 +11084,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             })) {
                 typeArgType = types_1.UnknownType.create();
             }
-            else if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeArgType)) {
-                addExpectedClassDiagnostic(typeArgType, typeArg.node);
-                typeArgType = types_1.UnknownType.create();
-            }
             // If this is an unpacked tuple, explode out the individual items.
             if ((0, types_1.isUnpackedClass)(typeArg.type) && typeArg.type.tupleTypeArguments) {
                 // This is an experimental feature because Unions of unpacked TypeVarTuples are not officially supported.
@@ -11128,7 +11134,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & (256 /* EvaluatorFlags.ExpectingTypeAnnotation */ | 262144 /* EvaluatorFlags.DisallowNakedGeneric */)) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 262144 /* EvalFlags.NoNakedGeneric */)) !== 0) {
                 addError(localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
             return classType;
@@ -11238,6 +11244,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (aliasMapEntry.isSpecialForm) {
             specialClassType.details.flags |= 8388608 /* ClassTypeFlags.SpecialFormClass */;
         }
+        if (aliasMapEntry.isIllegalInIsinstance) {
+            specialClassType.details.flags |= 16777216 /* ClassTypeFlags.IllegalIsinstanceClass */;
+        }
         // Synthesize a single type parameter with the specified variance if
         // specified in the alias map entry.
         if (aliasMapEntry.typeParamVariance !== undefined) {
@@ -11313,7 +11322,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ['TypedDict', { alias: '_TypedDict', module: 'self' }],
             ['Union', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Optional', { alias: '', module: 'builtins', isSpecialForm: true }],
-            ['Annotated', { alias: '', module: 'builtins', isSpecialForm: true }],
+            ['Annotated', { alias: '', module: 'builtins', isSpecialForm: true, isIllegalInIsinstance: true }],
             ['TypeAlias', { alias: '', module: 'builtins', isSpecialForm: true }],
             ['Concatenate', { alias: '', module: 'builtins', isSpecialForm: true }],
             [
@@ -11332,7 +11341,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         ]);
         const aliasMapEntry = specialTypes.get(assignedName);
         if (aliasMapEntry) {
-            const cachedType = readTypeCache(node, 0 /* EvaluatorFlags.None */);
+            const cachedType = readTypeCache(node, 0 /* EvalFlags.None */);
             if (cachedType) {
                 (0, debug_1.assert)((0, types_1.isInstantiableClass)(cachedType));
                 return cachedType;
@@ -11344,7 +11353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 specialType.details.baseClasses.push(strClass !== null && strClass !== void 0 ? strClass : types_1.AnyType.create());
                 (0, typeUtils_1.computeMroLinearization)(specialType);
             }
-            writeTypeCache(node, { type: specialType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node, { type: specialType }, 0 /* EvalFlags.None */);
             return specialType;
         }
         return undefined;
@@ -11393,30 +11402,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (isTypeCached(node)) {
             return;
         }
-        let flags = 0 /* EvaluatorFlags.None */;
+        let flags = 0 /* EvalFlags.None */;
         if (fileInfo.isStubFile) {
             // An assignment of ellipsis means "Any" within a type stub file.
-            flags |= 1 /* EvaluatorFlags.ConvertEllipsisToAny */;
+            flags |= 1 /* EvalFlags.ConvertEllipsisToAny */;
         }
         if (node.rightExpression.nodeType === 38 /* ParseNodeType.Name */ ||
             node.rightExpression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
             // Don't specialize a generic class on assignment (e.g. "x = list"
             // or "x = collections.OrderedDict") because we may want to later
             // specialize it (e.g. "x[int]").
-            flags |= 2 /* EvaluatorFlags.DoNotSpecialize */;
-        }
-        if (isDeclaredTypeAlias(node.leftExpression)) {
-            flags |=
-                128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-                    256 /* EvaluatorFlags.ExpectingTypeAnnotation */ |
-                    8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                    32 /* EvaluatorFlags.DisallowParamSpec */ |
-                    64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                    131072 /* EvaluatorFlags.DisallowClassVar */;
-            flags &= ~2 /* EvaluatorFlags.DoNotSpecialize */;
+            flags |= 2 /* EvalFlags.NoSpecialize */;
         }
         // Is this type already cached?
-        let rightHandType = readTypeCache(node.rightExpression, flags);
+        let rightHandType = readTypeCache(node.rightExpression, /* flags */ undefined);
         let isIncomplete = false;
         let expectedTypeDiagAddendum;
         if (!rightHandType) {
@@ -11425,89 +11424,94 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
                 rightHandType = handleTypingStubAssignment(node);
                 if (rightHandType) {
-                    writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* EvaluatorFlags.None */);
+                    writeTypeCache(node.rightExpression, { type: rightHandType }, 0 /* EvalFlags.None */);
                 }
             }
-            if (!rightHandType) {
-                // Determine whether there is a declared type.
-                const declaredType = getDeclaredTypeForExpression(node.leftExpression, {
-                    method: 'set',
-                });
-                let typeAliasNameNode;
-                let isSpeculativeTypeAlias = false;
-                if (isDeclaredTypeAlias(node.leftExpression)) {
-                    typeAliasNameNode = node.leftExpression.valueExpression;
-                    if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
-                    }
-                }
-                else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
-                    const symbolWithScope = lookUpSymbolRecursive(node.leftExpression, node.leftExpression.value, 
-                    /* honorCodeFlow */ false);
-                    if (symbolWithScope) {
-                        const decls = symbolWithScope.symbol.getDeclarations();
-                        if (decls.length === 1 && isPossibleTypeAliasOrTypedDict(decls[0])) {
+        }
+        if (!rightHandType) {
+            // Determine whether there is a declared type.
+            const declaredType = getDeclaredTypeForExpression(node.leftExpression, { method: 'set' });
+            let typeAliasNameNode;
+            let typeAliasPlaceholder;
+            let isSpeculativeTypeAlias = false;
+            if (isDeclaredTypeAlias(node.leftExpression)) {
+                flags =
+                    128 /* EvalFlags.InstantiableType */ |
+                        256 /* EvalFlags.TypeExpression */ |
+                        8 /* EvalFlags.StrLiteralAsType */ |
+                        32 /* EvalFlags.NoParamSpec */ |
+                        64 /* EvalFlags.NoTypeVarTuple */ |
+                        131072 /* EvalFlags.NoClassVar */;
+                typeAliasNameNode = node.leftExpression.valueExpression;
+                if (!isLegalTypeAliasExpressionForm(node.rightExpression)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAliasIllegalExpressionForm(), node.rightExpression);
+                }
+            }
+            else if (node.leftExpression.nodeType === 38 /* ParseNodeType.Name */) {
+                const symbolWithScope = lookUpSymbolRecursive(node.leftExpression, node.leftExpression.value, 
+                /* honorCodeFlow */ false);
+                if (symbolWithScope) {
+                    const decls = symbolWithScope.symbol.getDeclarations();
+                    if (decls.length === 1) {
+                        if (isPossibleTypeAliasDeclaration(decls[0])) {
                             typeAliasNameNode = node.leftExpression;
                             isSpeculativeTypeAlias = true;
+                            flags |= 33554432 /* EvalFlags.NoConvertSpecialForm */;
+                        }
+                        else if (isPossibleTypeDictFactoryCall(decls[0])) {
+                            // Handle calls to TypedDict factory functions like type
+                            // aliases to support recursive field type definitions.
+                            typeAliasNameNode = node.leftExpression;
                         }
                     }
                 }
-                // Synthesize a type variable that represents the type alias while we're
-                // evaluating it. This allows us to handle recursive definitions.
-                let typeAliasTypeVar;
-                if (typeAliasNameNode) {
-                    typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${typeAliasNameNode.value}`);
-                    typeAliasTypeVar.details.isSynthesized = true;
-                    typeAliasTypeVar.details.recursiveTypeAliasName = typeAliasNameNode.value;
-                    const scopeId = ParseTreeUtils.getScopeIdForNode(typeAliasNameNode);
-                    typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
-                    typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = false;
-                    typeAliasTypeVar.scopeId = scopeId;
-                    // Write the type back to the type cache. It will be replaced below.
-                    writeTypeCache(node, { type: typeAliasTypeVar }, /* flags */ undefined);
-                    writeTypeCache(node.leftExpression, { type: typeAliasTypeVar }, /* flags */ undefined);
-                    if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
-                        writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasTypeVar }, 
-                        /* flags */ undefined);
-                    }
-                }
-                const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
-                let srcType = srcTypeResult.type;
-                expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
-                if (srcTypeResult.isIncomplete) {
-                    isIncomplete = true;
+            }
+            if (typeAliasNameNode) {
+                typeAliasPlaceholder = synthesizeTypeAliasPlaceholder(typeAliasNameNode);
+                writeTypeCache(node, { type: typeAliasPlaceholder }, /* flags */ undefined);
+                writeTypeCache(node.leftExpression, { type: typeAliasPlaceholder }, /* flags */ undefined);
+                if (node.leftExpression.nodeType === 54 /* ParseNodeType.TypeAnnotation */) {
+                    writeTypeCache(node.leftExpression.valueExpression, { type: typeAliasPlaceholder }, 
+                    /* flags */ undefined);
                 }
+            }
+            const srcTypeResult = getTypeOfExpression(node.rightExpression, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
+            rightHandType = srcTypeResult.type;
+            expectedTypeDiagAddendum = srcTypeResult.expectedTypeDiagAddendum;
+            if (srcTypeResult.isIncomplete) {
+                isIncomplete = true;
+            }
+            // If this was a speculative type alias, it becomes a real type alias
+            // only if the evaluated type is an instantiable type.
+            if (isSpeculativeTypeAlias && !isLegalImplicitTypeAliasType(rightHandType)) {
+                typeAliasNameNode = undefined;
+            }
+            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, 
+                /* isPep695TypeVarType */ false);
+                if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasPlaceholder, rightHandType)) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
+                        name: typeAliasNameNode.value,
+                    }), node.rightExpression);
+                    rightHandType = types_1.UnknownType.create();
+                }
+                // Set the resulting type to the boundType of the original type alias
+                // to support recursive type aliases.
+                typeAliasPlaceholder.details.boundType = rightHandType;
+                // Record the type parameters within the recursive type alias so it
+                // can be specialized.
+                typeAliasPlaceholder.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
+            }
+            else {
                 // If the RHS is a constant boolean expression, assign it a literal type.
                 const constExprValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(node.rightExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
                 if (constExprValue !== undefined) {
                     const boolType = getBuiltInObject(node, 'bool');
                     if ((0, types_1.isClassInstance)(boolType)) {
-                        srcType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
-                    }
-                }
-                // If this is an enum, transform the type as required.
-                rightHandType = srcType;
-                if (typeAliasNameNode) {
-                    // If this was a speculative type alias, it becomes a real type alias
-                    // only if the evaluated type is an instantiable type.
-                    if (!isSpeculativeTypeAlias || isLegalImplicitTypeAliasType(rightHandType)) {
-                        // If this is a type alias, record its name based on the assignment target.
-                        rightHandType = transformTypeForTypeAlias(rightHandType, typeAliasNameNode, typeAliasNameNode, 
-                        /* isPep695Syntax */ false, 
-                        /* isPep695TypeVarType */ false);
-                        (0, debug_1.assert)(typeAliasTypeVar !== undefined);
-                        if ((0, typeUtils_1.isTypeAliasRecursive)(typeAliasTypeVar, rightHandType)) {
-                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasIsRecursiveDirect().format({
-                                name: typeAliasNameNode.value,
-                            }), node.rightExpression);
-                            rightHandType = types_1.UnknownType.create();
-                        }
-                        // Set the resulting type to the boundType of the original type alias
-                        // to support recursive type aliases.
-                        typeAliasTypeVar.details.boundType = rightHandType;
-                        // Record the type parameters within the recursive type alias so it
-                        // can be specialized.
-                        typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
+                        rightHandType = types_1.ClassType.cloneWithLiteral(boolType, constExprValue);
                     }
                 }
             }
@@ -11515,34 +11519,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         assignTypeToExpression(node.leftExpression, { type: rightHandType, isIncomplete }, node.rightExpression, 
         /* ignoreEmptyContainers */ true, 
         /* allowAssignmentToFinalVar */ true, expectedTypeDiagAddendum);
-        writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* EvaluatorFlags.None */);
-    }
-    function isPossibleTypeAliasOrTypedDict(decl) {
-        var _a;
-        if (isPossibleTypeAliasDeclaration(decl)) {
-            return true;
-        }
-        if (decl.type === 1 /* DeclarationType.Variable */ &&
-            decl.node.parent &&
-            decl.node.parent.nodeType === 3 /* ParseNodeType.Assignment */ &&
-            ((_a = decl.node.parent.rightExpression) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
-            const callLeftNode = decl.node.parent.rightExpression.leftExpression;
-            // Use a simple heuristic to determine whether this is potentially
-            // a call to the TypedDict call. This avoids the expensive (and potentially
-            // recursive) call to getTypeOfExpression in cases where it's not needed.
-            if ((callLeftNode.nodeType === 38 /* ParseNodeType.Name */ && callLeftNode.value) === 'TypedDict' ||
-                (callLeftNode.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
-                    callLeftNode.memberName.value === 'TypedDict' &&
-                    callLeftNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */)) {
-                // See if this is a call to TypedDict. We want to support
-                // recursive type references in a TypedDict call.
-                const callType = getTypeOfExpression(callLeftNode, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
-                if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
-                    return true;
-                }
-            }
-        }
-        return false;
+        writeTypeCache(node, { type: rightHandType, isIncomplete }, 0 /* EvalFlags.None */);
+    }
+    // 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) {
+        const placeholder = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.value}`);
+        placeholder.details.isSynthesized = true;
+        placeholder.details.recursiveTypeAliasName = nameNode.value;
+        const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
+        placeholder.details.recursiveTypeAliasScopeId = scopeId;
+        placeholder.details.recursiveTypeAliasIsPep695Syntax = false;
+        placeholder.scopeId = scopeId;
+        return placeholder;
     }
     // Evaluates the type of a type alias (i.e. "type") statement. This code
     // path does not handle traditional type aliases, which are treated as
@@ -11560,20 +11549,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // This function is common to the handling of "type" statements and explicit
     // calls to the TypeAliasType constructor.
     function getTypeOfTypeAliasCommon(declNode, nameNode, valueNode, isPep695Syntax, typeParamNodes, getTypeParamCallback) {
-        const cachedType = readTypeCache(nameNode, 0 /* EvaluatorFlags.None */);
+        const cachedType = readTypeCache(nameNode, 0 /* EvalFlags.None */);
         if (cachedType) {
             return cachedType;
         }
         // Synthesize a type variable that represents the type alias while we're
         // evaluating it. This allows us to handle recursive definitions.
-        const typeAliasTypeVar = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.value}`);
-        typeAliasTypeVar.details.isSynthesized = true;
-        typeAliasTypeVar.details.recursiveTypeAliasName = nameNode.value;
-        const scopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
-        typeAliasTypeVar.details.recursiveTypeAliasScopeId = scopeId;
-        typeAliasTypeVar.details.recursiveTypeAliasIsPep695Syntax = isPep695Syntax;
-        typeAliasTypeVar.scopeId = scopeId;
-        // Write the type to the type cache. It will be replaced below.
+        const typeAliasTypeVar = synthesizeTypeAliasPlaceholder(nameNode);
+        // 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.
         const scope = ScopeUtils.getScopeForNode(declNode);
@@ -11605,7 +11588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Set the resulting type to the boundType of the original type alias
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
-        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, 0 /* EvalFlags.None */);
         return aliasType;
     }
     function evaluateTypesForAugmentedAssignment(node) {
@@ -11613,7 +11596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return;
         }
         const destTypeResult = (0, operations_1.getTypeOfAugmentedAssignment)(evaluatorInterface, node, /* inferenceContext */ undefined);
-        writeTypeCache(node, destTypeResult, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, destTypeResult, 0 /* EvalFlags.None */);
     }
     function getPseudoGenericTypeVarName(paramName) {
         return `__type_of_${paramName}`;
@@ -11621,7 +11604,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfClass(node) {
         initializePrefetchedTypes(node);
         // Is this type already cached?
-        const cachedClassType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
+        const cachedClassType = readTypeCache(node.name, 0 /* EvalFlags.None */);
         if (cachedClassType) {
             if (!(0, types_1.isInstantiableClass)(cachedClassType)) {
                 // This can happen in rare circumstances where the class declaration
@@ -11630,7 +11613,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return {
                 classType: cachedClassType,
-                decoratedType: readTypeCache(node, 0 /* EvaluatorFlags.None */) || types_1.UnknownType.create(),
+                decoratedType: readTypeCache(node, 0 /* EvalFlags.None */) || types_1.UnknownType.create(),
             };
         }
         // The type wasn't cached, so we need to create a new one.
@@ -11695,14 +11678,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let isNamedTupleSubclass = false;
             const initSubclassArgs = [];
             let metaclassNode;
-            let exprFlags = 128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-                1024 /* EvaluatorFlags.AllowGenericClassType */ |
-                262144 /* EvaluatorFlags.DisallowNakedGeneric */ |
-                2048 /* EvaluatorFlags.DisallowTypeVarsWithScopeId */ |
-                8192 /* EvaluatorFlags.AssociateTypeVarsWithCurrentScope */ |
-                16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */;
+            let exprFlags = 128 /* EvalFlags.InstantiableType */ |
+                1024 /* EvalFlags.AllowGeneric */ |
+                262144 /* EvalFlags.NoNakedGeneric */ |
+                2048 /* EvalFlags.NoTypeVarWithScopeId */ |
+                8192 /* EvalFlags.TypeVarGetsCurScope */ |
+                16384 /* EvalFlags.EnforceVarianceConsistency */;
             if (fileInfo.isStubFile) {
-                exprFlags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
+                exprFlags |= 4 /* EvalFlags.ForwardRefs */;
             }
             node.arguments.forEach((arg) => {
                 // Ignore unpacked arguments.
@@ -12185,9 +12168,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             };
             // Update the undecorated class type.
-            writeTypeCache(node.name, { type: classType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node.name, { type: classType }, 0 /* EvalFlags.None */);
             // Update the decorated class type.
-            writeTypeCache(node, { type: decoratedType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node, { type: decoratedType }, 0 /* EvalFlags.None */);
             return { classType, decoratedType };
         });
     }
@@ -12297,7 +12280,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!typeOfParam || !(0, types_1.isTypeVar)(typeOfParam)) {
                 return;
             }
-            writeTypeCache(param.name, { type: typeOfParam }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(param.name, { type: typeOfParam }, 0 /* EvalFlags.None */);
             paramTypes.push(typeOfParam);
         });
         return paramTypes;
@@ -12397,7 +12380,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         deferredClassCompletions.forEach((e) => {
             if (types_1.ClassType.isSameGenericClass(e.dependsUpon, type)) {
                 e.classesToComplete.forEach((classNode) => {
-                    const classType = readTypeCache(classNode.name, 0 /* EvaluatorFlags.None */);
+                    const classType = readTypeCache(classNode.name, 0 /* EvalFlags.None */);
                     if (classType) {
                         completeClassTypeDeferred(classType, classNode.name);
                     }
@@ -12543,7 +12526,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfFunction(node) {
         initializePrefetchedTypes(node);
         // Is this predecorated function type cached?
-        let functionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
+        let functionType = readTypeCache(node.name, 0 /* EvalFlags.None */);
         if (functionType) {
             if (!(0, types_1.isFunction)(functionType)) {
                 // This can happen in certain rare circumstances where the
@@ -12558,7 +12541,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             functionType = getTypeOfFunctionPredecorated(node);
         }
         // Is the decorated function type cached?
-        let decoratedType = readTypeCache(node, 0 /* EvaluatorFlags.None */);
+        let decoratedType = readTypeCache(node, 0 /* EvalFlags.None */);
         if (decoratedType) {
             return { functionType, decoratedType };
         }
@@ -12599,7 +12582,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
-        writeTypeCache(node, { type: decoratedType }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: decoratedType }, 0 /* EvalFlags.None */);
         return { functionType, decoratedType };
     }
     // Evaluates the type of a "def" statement without applying an async
@@ -12608,7 +12591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         // Is this type already cached?
-        const cachedFunctionType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
+        const cachedFunctionType = readTypeCache(node.name, 0 /* EvalFlags.None */);
         if (cachedFunctionType && (0, types_1.isFunction)(cachedFunctionType)) {
             return cachedFunctionType;
         }
@@ -12780,7 +12763,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (types_1.FunctionType.isOverloaded(functionType) || types_1.FunctionType.isAbstractMethod(functionType)) {
                         treatEllipsisAsAny = true;
                     }
-                    defaultValueType = getTypeOfExpression(param.defaultValue, treatEllipsisAsAny ? 1 /* EvaluatorFlags.ConvertEllipsisToAny */ : 0 /* EvaluatorFlags.None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
+                    defaultValueType = getTypeOfExpression(param.defaultValue, treatEllipsisAsAny ? 1 /* EvalFlags.ConvertEllipsisToAny */ : 0 /* EvalFlags.None */, (0, typeUtils_1.makeInferenceContext)(annotatedType)).type;
                 }
                 if (annotatedType) {
                     // If there was both a type annotation and a default value, verify
@@ -12873,7 +12856,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isUnknown)(paramType)) {
                         functionType.details.flags |= 16384 /* FunctionTypeFlags.UnannotatedParams */;
                     }
-                    writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvaluatorFlags.None */);
+                    writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvalFlags.None */);
                 }
             });
             // If the function ends in P.args and P.kwargs parameters, make it exempt from
@@ -12954,7 +12937,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Clear the "partially evaluated" flag to indicate that the functionType
             // is fully evaluated.
             functionType.details.flags &= ~131072 /* FunctionTypeFlags.PartiallyEvaluated */;
-            writeTypeCache(node.name, { type: functionType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node.name, { type: functionType }, 0 /* EvalFlags.None */);
             return functionType;
         });
     }
@@ -13019,6 +13002,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 // Replace any unsolved TypeVars with Unknown (including all function-scoped TypeVars).
                                 inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext, {
                                     unknownIfNotFound: true,
+                                    tupleClassType: getTupleClassType(),
                                 });
                             }
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
@@ -13040,7 +13024,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function inferParameterTypeFromDefaultValue(paramValueExpr) {
-        const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvaluatorFlags.ConvertEllipsisToAny */).type;
+        const defaultValueType = getTypeOfExpression(paramValueExpr, 1 /* EvalFlags.ConvertEllipsisToAny */).type;
         let inferredParamType;
         // Is the default value a "None" or an instance of some private class (one
         // whose name starts with an underscore)? If so, we will assume that the
@@ -13176,7 +13160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         // Is this type already cached?
-        let inferredReturnType = readTypeCache(node.suite, 0 /* EvaluatorFlags.None */);
+        let inferredReturnType = readTypeCache(node.suite, 0 /* EvalFlags.None */);
         let isIncomplete = false;
         if (inferredReturnType) {
             return { type: inferredReturnType, isIncomplete };
@@ -13324,7 +13308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                 }
-                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, 0 /* EvaluatorFlags.None */);
+                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, 0 /* EvalFlags.None */);
             }
             finally {
                 functionRecursionMap.delete(node.id);
@@ -13343,6 +13327,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             !functionDecl.raiseStatements) {
             return false;
         }
+        const statements = functionDecl.node.suite.statements;
+        if (statements.some((statement) => statement.nodeType !== 47 /* ParseNodeType.StatementList */)) {
+            return false;
+        }
         for (const raiseStatement of functionDecl.raiseStatements) {
             if (!raiseStatement.typeExpression || raiseStatement.valueExpression) {
                 return false;
@@ -13367,7 +13355,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const iteratorTypeResult = getTypeOfExpression(node.iterableExpression);
         const iteratedType = (_b = (_a = getTypeOfIterator(iteratorTypeResult, !!node.isAsync, node.iterableExpression)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
         assignTypeToExpression(node.targetExpression, { type: iteratedType, isIncomplete: iteratorTypeResult.isIncomplete }, node.targetExpression);
-        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForExceptStatement(node) {
         // This should be called only if the except node has a target exception.
@@ -13417,7 +13405,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.name) {
             assignTypeToExpression(node.name, { type: targetType }, node.name);
         }
-        writeTypeCache(node, { type: targetType }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: targetType }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForWithStatement(node) {
         if (isTypeCached(node)) {
@@ -13479,7 +13467,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.target) {
             assignTypeToExpression(node.target, { type: scopedType, isIncomplete: exprTypeResult.isIncomplete }, node.target);
         }
-        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForImportAs(node) {
         var _a;
@@ -13504,14 +13492,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let symbolType = (_a = getAliasedSymbolTypeForName(node, symbolNameNode.value)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         // Is there a cached module type associated with this node? If so, use
         // it instead of the type we just created.
-        const cachedModuleType = readTypeCache(node, 0 /* EvaluatorFlags.None */);
+        const cachedModuleType = readTypeCache(node, 0 /* EvalFlags.None */);
         if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
             if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
                 symbolType = cachedModuleType;
             }
         }
         assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: symbolType }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForImportFromAs(node) {
         var _a;
@@ -13577,7 +13565,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         assignTypeToNameNode(aliasNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: symbolType }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForMatchStatement(node) {
         if (isTypeCached(node)) {
@@ -13592,7 +13580,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* isPositiveTest */ false);
             }
         }
-        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForCaseStatement(node) {
         if (isTypeCached(node)) {
@@ -13622,7 +13610,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         const narrowedSubjectType = (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, node.pattern);
-        writeTypeCache(node, { type: narrowedSubjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node, { type: narrowedSubjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForImportFrom(node) {
         if (isTypeCached(node)) {
@@ -13630,7 +13618,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (node.isWildcardImport) {
             // Write back a dummy type so we don't evaluate this node again.
-            writeTypeCache(node, { type: types_1.AnyType.create() }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node, { type: types_1.AnyType.create() }, 0 /* EvalFlags.None */);
             const flowNode = AnalyzerNodeInfo.getFlowNode(node);
             if (flowNode && (flowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) !== 0) {
                 const wildcardFlowNode = flowNode;
@@ -13668,14 +13656,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Is there a cached module type associated with this node? If so, use
             // it instead of the type we just created.
-            const cachedModuleType = readTypeCache(node, 0 /* EvaluatorFlags.None */);
+            const cachedModuleType = readTypeCache(node, 0 /* EvalFlags.None */);
             if (cachedModuleType && (0, types_1.isModule)(cachedModuleType) && symbolType) {
                 if ((0, types_1.isTypeSame)(symbolType, cachedModuleType)) {
                     symbolType = cachedModuleType;
                 }
             }
             assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
-            writeTypeCache(node, { type: symbolType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node, { type: symbolType }, 0 /* EvalFlags.None */);
         }
     }
     function evaluateTypesForTypeAnnotationNode(node) {
@@ -13692,7 +13680,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.valueExpression),
                 allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
             });
-            writeTypeCache(node.valueExpression, { type: annotationType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node.valueExpression, { type: annotationType }, 0 /* EvalFlags.None */);
         }
     }
     function getAliasedSymbolTypeForName(node, name) {
@@ -13782,7 +13770,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (node.parent.nodeType === 32 /* ParseNodeType.Global */ || node.parent.nodeType === 39 /* ParseNodeType.Nonlocal */) {
                 // For global and nonlocal statements, allow forward references so
                 // we don't use code flow during symbol lookups.
-                getTypeOfExpression(node, 4 /* EvaluatorFlags.AllowForwardReferences */);
+                getTypeOfExpression(node, 4 /* EvalFlags.ForwardRefs */);
                 return;
             }
             if (node.parent.nodeType === 37 /* ParseNodeType.ModuleName */) {
@@ -13842,7 +13830,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Scan up the parse tree until we find a node that doesn't
         // require any context to be evaluated.
         let nodeToEvaluate = node;
-        let flags = 0 /* EvaluatorFlags.None */;
+        let flags = 0 /* EvalFlags.None */;
         while (true) {
             // If we're within an argument node in a call or index expression, skip
             // all of the nodes between because the entire argument expression
@@ -13872,6 +13860,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 nodeToEvaluate = parent;
                 continue;
             }
+            // Forward-declared type annotation expressions need to be be evaluated
+            // in context so they have the appropriate flags set. Most of these cases
+            // will have been detected above when calling getParentAnnotationNode,
+            // but TypeAlias expressions are not handled there.
+            const stringEnclosure = ParseTreeUtils.getParentNodeOfType(parent, 48 /* ParseNodeType.StringList */);
+            if (stringEnclosure) {
+                nodeToEvaluate = stringEnclosure;
+                continue;
+            }
             // The left expression of a call or member access expression is not generally contextual.
             if (parent.nodeType === 9 /* ParseNodeType.Call */ || parent.nodeType === 35 /* ParseNodeType.MemberAccess */) {
                 if (nodeToEvaluate === parent.leftExpression) {
@@ -13887,25 +13884,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         nodeToEvaluate = parent;
                         continue;
                     }
-                    flags = 2 /* EvaluatorFlags.CallBaseDefaults */;
+                    flags = 2 /* EvalFlags.CallBaseDefaults */;
                     break;
                 }
             }
             else if (parent.nodeType === 27 /* ParseNodeType.Index */) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
-                    flags = 2 /* EvaluatorFlags.IndexBaseDefaults */;
-                    break;
+                    flags = 2 /* EvalFlags.IndexBaseDefaults */;
                 }
             }
-            else if (parent.nodeType === 48 /* ParseNodeType.StringList */ && nodeToEvaluate === parent.typeAnnotation) {
-                // Forward-declared type annotation expressions need to be be evaluated
-                // in context so they have the appropriate flags set. Most of these cases
-                // will have been detected above when calling getParentAnnotationNode,
-                // but TypeAlias expressions are not handled there.
-                nodeToEvaluate = parent;
-                continue;
-            }
             if (!(0, parseNodes_1.isExpressionNode)(parent)) {
                 // If we've hit a non-expression node, we generally want to
                 // stop. However, there are a few special "pass through"
@@ -14001,7 +13989,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const declaredReturnType = enclosingFunctionNode
                         ? getFunctionDeclaredReturnType(enclosingFunctionNode)
                         : undefined;
-                    getTypeOfExpression(parent.returnExpression, 0 /* EvaluatorFlags.None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
+                    getTypeOfExpression(parent.returnExpression, 0 /* EvalFlags.None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
                     return;
                 }
                 break;
@@ -14043,7 +14031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const param = functionNode.parameters[paramIndex];
             const annotatedType = getTypeOfParameterAnnotation(typeAnnotation, functionNode.parameters[paramIndex].category);
             const adjType = transformVariadicParamType(node, node.category, adjustParameterAnnotatedType(param, annotatedType));
-            writeTypeCache(node.name, { type: adjType }, 0 /* EvaluatorFlags.None */);
+            writeTypeCache(node.name, { type: adjType }, 0 /* EvalFlags.None */);
             return;
         }
         const containingClassNode = ParseTreeUtils.getEnclosingClass(functionNode, /* stopAtFunction */ true);
@@ -14054,7 +14042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const typeParamName = getPseudoGenericTypeVarName(node.name.value);
             const paramType = classInfo.classType.details.typeParameters.find((param) => param.details.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.name, { type: paramType }, 0 /* EvaluatorFlags.None */);
+                writeTypeCache(node.name, { type: paramType }, 0 /* EvalFlags.None */);
                 return;
             }
         }
@@ -14064,7 +14052,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, functionNode, 
         /* isInClass */ true).flags;
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
-        writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* EvaluatorFlags.None */);
+        writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* EvalFlags.None */);
     }
     // Evaluates the types that are assigned within the statement that contains
     // the specified parse node. In some cases, a broader statement may need to
@@ -14178,7 +14166,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // don't bother doing additional work.
         let cacheEntry = readTypeCacheEntry(subnode);
         if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
-            return cacheEntry.typeResult;
+            const typeResult = cacheEntry.typeResult;
+            // Handle the special case where a function or class is partially evaluated.
+            // Indicate that these are not complete types.
+            if ((0, types_1.isFunction)(typeResult.type) && types_1.FunctionType.isPartiallyEvaluated(typeResult.type)) {
+                return { ...typeResult, isIncomplete: true };
+            }
+            if ((0, types_1.isClass)(typeResult.type) && types_1.ClassType.isPartiallyEvaluated(typeResult.type)) {
+                return { ...typeResult, isIncomplete: true };
+            }
+            return typeResult;
         }
         callback();
         cacheEntry = readTypeCacheEntry(subnode);
@@ -14292,9 +14289,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { type: createClassVarType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Protocol': {
-                    if ((flags &
-                        (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
-                        0) {
+                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
                         addError(localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
                     typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.forEach((typeArg) => {
@@ -14309,17 +14304,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     };
                 }
                 case 'TypedDict': {
-                    if ((flags &
-                        (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
-                        0) {
+                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
                         addError(localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                     }
                     break;
                 }
                 case 'Literal': {
-                    if ((flags &
-                        (67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */)) !==
-                        0) {
+                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
                         addError(localize_1.LocMessage.literalNotAllowed(), errorNode);
                     }
                     break;
@@ -14342,7 +14333,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { type: createFinalType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Annotated': {
-                    return createAnnotatedType(classType, errorNode, typeArgs);
+                    return createAnnotatedType(classType, errorNode, typeArgs, flags);
                 }
                 case 'Concatenate': {
                     return { type: createConcatenateType(classType, errorNode, typeArgs, flags) };
@@ -14373,7 +14364,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (fileInfo.isStubFile ||
             fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion_1.pythonVersion3_9) ||
             (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) ||
-            (flags & 4 /* EvaluatorFlags.AllowForwardReferences */) !== 0) {
+            (flags & 4 /* EvalFlags.ForwardRefs */) !== 0) {
             // Handle "type" specially, since it needs to act like "Type"
             // in Python 3.9 and newer.
             if (types_1.ClassType.isBuiltIn(classType, 'type') && typeArgs) {
@@ -14560,7 +14551,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeVarContext.setTypeVarType(typeParam, typeArgType);
                 return;
             }
-            const solvedDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeParam, typeVarContext, { unknownIfNotFound: true });
+            const solvedDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeParam, typeVarContext, {
+                unknownIfNotFound: true,
+                tupleClassType: getTupleClassType(),
+            });
             typeArgTypes.push(solvedDefaultType);
             if ((0, types_1.isParamSpec)(typeParam)) {
                 typeVarContext.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(solvedDefaultType));
@@ -14574,7 +14568,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 let adjustedTypeArgType = applyTypeArgToTypeVar(typeParameters[index], typeArgType, diag);
                 // Determine if the variance must match.
-                if (adjustedTypeArgType && (flags & 16384 /* EvaluatorFlags.EnforceTypeVarVarianceConsistency */) !== 0) {
+                if (adjustedTypeArgType && (flags & 16384 /* EvalFlags.EnforceVarianceConsistency */) !== 0) {
                     const destType = typeParameters[index];
                     const declaredVariance = destType.details.declaredVariance;
                     if (!(0, typeUtils_1.isVarianceOfTypeArgumentCompatible)(adjustedTypeArgType, declaredVariance)) {
@@ -14643,39 +14637,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getTypeOfExpressionExpectingType(arg.valueExpression, options);
     }
     function getTypeOfExpressionExpectingType(node, options) {
-        let flags = 128 /* EvaluatorFlags.ExpectingInstantiableType */ |
-            8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-            131072 /* EvaluatorFlags.DisallowClassVar */;
+        let flags = 128 /* EvalFlags.InstantiableType */ | 8 /* EvalFlags.StrLiteralAsType */ | 131072 /* EvalFlags.NoClassVar */;
         if (options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId) {
-            flags |= 4096 /* EvaluatorFlags.AllowTypeVarsWithoutScopeId */;
+            flags |= 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */;
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile || (options === null || options === void 0 ? void 0 : options.allowForwardReference)) {
-            flags |= 4 /* EvaluatorFlags.AllowForwardReferences */;
+            flags |= 4 /* EvalFlags.ForwardRefs */;
         }
         else {
-            flags |= 4194304 /* EvaluatorFlags.InterpreterParsesStringLiteral */;
+            flags |= 8388608 /* EvalFlags.ParsesStringLiteral */;
         }
         if (!options || !options.allowFinal) {
-            flags |= 16 /* EvaluatorFlags.DisallowFinal */;
+            flags |= 16 /* EvalFlags.NoFinal */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowRequired) {
-            flags |= 1048576 /* EvaluatorFlags.AllowRequired */ | 256 /* EvaluatorFlags.ExpectingTypeAnnotation */;
+            flags |= 1048576 /* EvalFlags.AllowRequired */ | 256 /* EvalFlags.TypeExpression */;
         }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTuple) {
-            flags |= 2097152 /* EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple */;
+            flags |= 2097152 /* EvalFlags.AllowUnpackedTuple */;
         }
         else {
-            flags |= 64 /* EvaluatorFlags.DisallowTypeVarTuple */;
+            flags |= 64 /* EvalFlags.NoTypeVarTuple */;
         }
         if (!options || !options.allowParamSpec) {
-            flags |= 32 /* EvaluatorFlags.DisallowParamSpec */;
+            flags |= 32 /* EvalFlags.NoParamSpec */;
         }
         if (options === null || options === void 0 ? void 0 : options.enforceTypeAnnotationRules) {
-            flags |= 256 /* EvaluatorFlags.ExpectingTypeAnnotation */;
+            flags |= 256 /* EvalFlags.TypeExpression */;
         }
         if (options === null || options === void 0 ? void 0 : options.disallowProtocolAndTypedDict) {
-            flags |= 67108864 /* EvaluatorFlags.DisallowNonTypeSpecialForms */;
+            flags |= 67108864 /* EvalFlags.NoNonTypeSpecialForms */;
         }
         return getTypeOfExpression(node, flags);
     }
@@ -15091,10 +15083,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (declaration.intrinsicType === 'Any') {
                     return { type: types_1.AnyType.create() };
                 }
-                if (declaration.intrinsicType === 'class') {
+                if (declaration.intrinsicType === 'type[self]') {
                     const classNode = ParseTreeUtils.getEnclosingClass(declaration.node);
                     const classTypeInfo = getTypeOfClass(classNode);
-                    return { type: classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType };
+                    return {
+                        type: classTypeInfo
+                            ? (0, typeUtils_1.synthesizeTypeVarForSelfCls)(classTypeInfo.classType, /* isClsParam */ true)
+                            : types_1.UnknownType.create(),
+                    };
                 }
                 const strType = getBuiltInObject(declaration.node, 'str');
                 const intType = getBuiltInObject(declaration.node, 'int');
@@ -15207,7 +15203,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfTypeParameter(node) {
         // Is this type already cached?
-        const cachedTypeVarType = readTypeCache(node.name, 0 /* EvaluatorFlags.None */);
+        const cachedTypeVarType = readTypeCache(node.name, 0 /* EvalFlags.None */);
         if (cachedTypeVarType && (0, types_1.isTypeVar)(cachedTypeVarType)) {
             return cachedTypeVarType;
         }
@@ -15416,7 +15412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 // Special-case calls to certain built-in type functions.
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* ParseNodeType.Call */) {
-                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+                    const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
                     const callType = baseTypeResult.type;
                     const exemptBuiltins = [
                         'TypeVar',
@@ -16097,7 +16093,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramType = stripLiteralValue(paramType);
                         }
                         paramTypes.push(paramType);
-                        writeTypeCache(param.name, { type: paramType }, 0 /* EvaluatorFlags.None */);
+                        writeTypeCache(param.name, { type: paramType }, 0 /* EvalFlags.None */);
                     }
                 });
                 // Don't bother trying to determine the contextual return
@@ -16162,46 +16158,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfMember(member) {
         if ((0, types_1.isInstantiableClass)(member.classType)) {
             return (0, typeUtils_1.partiallySpecializeType)(getEffectiveTypeOfSymbol(member.symbol), member.classType, 
-            /* selfClass */ undefined, typeClass !== null && typeClass !== void 0 ? typeClass : types_1.UnknownType.create());
+            /* selfClass */ undefined, typeClass && (0, types_1.isInstantiableClass)(typeClass) ? typeClass : undefined);
         }
         return types_1.UnknownType.create();
     }
     function getTypeOfMemberInternal(errorNode, member, selfClass, flags) {
-        if ((0, types_1.isInstantiableClass)(member.classType)) {
-            const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
-            if (typeResult) {
-                // If the type is a function or overloaded function, infer
-                // and cache the return type if necessary. This needs to be done
-                // prior to specializing.
-                inferReturnTypeIfNecessary(typeResult.type);
-                // Check for ambiguous accesses to attributes with generic types?
-                if (errorNode &&
-                    selfClass &&
-                    (0, types_1.isClass)(selfClass) &&
-                    member.isInstanceMember &&
-                    (0, types_1.isClass)(member.unspecializedClassType) &&
-                    (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
-                    (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
-                    const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, (0, typeUtils_1.selfSpecializeClass)(selfClass, /* overrideTypeArgs */ true));
-                    if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
-                        !(0, types_1.isOverloadedFunction)(subtype) &&
-                        (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
-                    }
-                }
-                return {
-                    type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
-                    isIncomplete: !!typeResult.isIncomplete,
-                };
-            }
-        }
-        else if ((0, types_1.isAnyOrUnknown)(member.classType)) {
+        if ((0, types_1.isAnyOrUnknown)(member.classType)) {
             return {
                 type: member.classType,
                 isIncomplete: false,
             };
         }
-        return undefined;
+        if (!(0, types_1.isInstantiableClass)(member.classType)) {
+            return undefined;
+        }
+        const typeResult = getEffectiveTypeOfSymbolForUsage(member.symbol);
+        if (!typeResult) {
+            return undefined;
+        }
+        // Report inappropriate use of variables in type expressions.
+        if ((flags & 2048 /* MemberAccessFlags.TypeExpression */) !== 0 && errorNode) {
+            typeResult.type = validateSymbolIsTypeExpression(errorNode, typeResult.type, !!typeResult.includesVariableDecl);
+        }
+        // If the type is a function or overloaded function, infer
+        // and cache the return type if necessary. This needs to be done
+        // prior to specializing.
+        inferReturnTypeIfNecessary(typeResult.type);
+        // Check for ambiguous accesses to attributes with generic types?
+        if (errorNode &&
+            selfClass &&
+            (0, types_1.isClass)(selfClass) &&
+            member.isInstanceMember &&
+            (0, types_1.isClass)(member.unspecializedClassType) &&
+            (flags & 1024 /* MemberAccessFlags.DisallowGenericInstanceVariableAccess */) !== 0 &&
+            (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
+            const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, (0, typeUtils_1.selfSpecializeClass)(selfClass, /* overrideTypeArgs */ true));
+            if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
+                !(0, types_1.isOverloadedFunction)(subtype) &&
+                (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
+            }
+        }
+        return {
+            type: (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.classType, selfClass),
+            isIncomplete: !!typeResult.isIncomplete,
+        };
     }
     function assignClass(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, reportErrorsUsingObjType) {
         // If the source or dest types are partially evaluated (i.e. they are in the
@@ -17333,7 +17334,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
                     return true;
                 }
             }
@@ -18458,7 +18459,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             assignedType.typeArguments.length <= assignedType.details.typeParameters.length &&
             !assignedType.tupleTypeArguments) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
-            (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
+            (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
             /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
             let replacedTypeArg = false;
@@ -19261,8 +19262,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return true;
     }
     function isLegalImplicitTypeAliasType(type) {
-        // We explicitly exclude "Unknown" and "...".
-        if ((0, types_1.isUnknown)(type) || (0, typeUtils_1.isEllipsisType)(type)) {
+        // We explicitly exclude "..." and "Unknown".
+        if ((0, typeUtils_1.isEllipsisType)(type)) {
+            return false;
+        }
+        if ((0, types_1.isUnknown)(type)) {
+            // If this is a union type, we'll assume that it was meant as a type
+            // alias even though all of the union subtypes are Unknown.
+            if (type.specialForm && types_1.ClassType.isBuiltIn(type.specialForm, 'UnionType')) {
+                return true;
+            }
             return false;
         }
         // Look at the subtypes within the union. If any of them are not
@@ -19276,6 +19285,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return isLegal;
     }
+    function isPossibleTypeAliasOrTypedDict(decl) {
+        return isPossibleTypeAliasDeclaration(decl) || isPossibleTypeDictFactoryCall(decl);
+    }
+    function isPossibleTypeDictFactoryCall(decl) {
+        var _a;
+        if (decl.type !== 1 /* DeclarationType.Variable */ ||
+            !decl.node.parent ||
+            decl.node.parent.nodeType !== 3 /* ParseNodeType.Assignment */ ||
+            ((_a = decl.node.parent.rightExpression) === null || _a === void 0 ? void 0 : _a.nodeType) !== 9 /* ParseNodeType.Call */) {
+            return false;
+        }
+        const callLeftNode = decl.node.parent.rightExpression.leftExpression;
+        // Use a simple heuristic to determine whether this is potentially
+        // a call to the TypedDict call. This avoids the expensive (and potentially
+        // recursive) call to getTypeOfExpression in cases where it's not needed.
+        if ((callLeftNode.nodeType === 38 /* ParseNodeType.Name */ && callLeftNode.value) === 'TypedDict' ||
+            (callLeftNode.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
+                callLeftNode.memberName.value === 'TypedDict' &&
+                callLeftNode.leftExpression.nodeType === 38 /* ParseNodeType.Name */)) {
+            // See if this is a call to TypedDict. We want to support
+            // recursive type references in a TypedDict call.
+            const callType = getTypeOfExpression(callLeftNode, 2 /* EvalFlags.CallBaseDefaults */).type;
+            if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'TypedDict')) {
+                return true;
+            }
+        }
+        return false;
+    }
     function printObjectTypeForClass(type) {
         return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
     }