diff --git a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts
index 6abeb2870..7a1064f77 100644
--- a/packages/pyright-internal/src/analyzer/codeFlowEngine.ts
+++ b/packages/pyright-internal/src/analyzer/codeFlowEngine.ts
@@ -41,7 +41,7 @@ import { isMatchingExpression, isPartialMatchingExpression, printExpression } fr
 import { getPatternSubtypeNarrowingCallback } from './patternMatching';
 import { SpeculativeTypeTracker } from './typeCacheUtils';
 import { narrowForKeyAssignment } from './typedDicts';
-import { EvaluatorFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { EvalFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
 import { getTypeNarrowingCallback } from './typeGuards';
 import {
     ClassType,
@@ -1485,7 +1485,7 @@ export function getCodeFlowEngine(
 
                                 const classType = evaluator.getTypeOfExpression(
                                     classPatternNode.className,
-                                    EvaluatorFlags.CallBaseDefaults
+                                    EvalFlags.CallBaseDefaults
                                 ).type;
 
                                 if (isInstantiableClass(classType)) {
@@ -1534,12 +1534,12 @@ export function getCodeFlowEngine(
                             const arg1Expr = testExpression.arguments[1].valueExpression;
                             const arg1Type = evaluator.getTypeOfExpression(
                                 arg1Expr,
-                                EvaluatorFlags.AllowMissingTypeArgs |
-                                    EvaluatorFlags.EvaluateStringLiteralAsType |
-                                    EvaluatorFlags.DisallowParamSpec |
-                                    EvaluatorFlags.DisallowTypeVarTuple |
-                                    EvaluatorFlags.DisallowFinal |
-                                    EvaluatorFlags.DoNotSpecialize
+                                EvalFlags.AllowMissingTypeArgs |
+                                    EvalFlags.StrLiteralAsType |
+                                    EvalFlags.NoParamSpec |
+                                    EvalFlags.NoTypeVarTuple |
+                                    EvalFlags.NoFinal |
+                                    EvalFlags.NoSpecialize
                             ).type;
 
                             if (isInstantiableClass(arg1Type)) {
@@ -1659,7 +1659,7 @@ export function getCodeFlowEngine(
             let subtypeCount = 0;
 
             // Evaluate the call base type.
-            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, EvaluatorFlags.CallBaseDefaults);
+            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, EvalFlags.CallBaseDefaults);
             const callType = callTypeResult.type;
 
             doForEachSubtype(callType, (callSubtype) => {
diff --git a/packages/pyright-internal/src/analyzer/dataClasses.ts b/packages/pyright-internal/src/analyzer/dataClasses.ts
index 3d086e216..d57d96ac2 100644
--- a/packages/pyright-internal/src/analyzer/dataClasses.ts
+++ b/packages/pyright-internal/src/analyzer/dataClasses.ts
@@ -33,7 +33,7 @@ import { getClassFullName, getEnclosingClassOrFunction, getScopeIdForNode, getTy
 import { evaluateStaticBoolExpression } from './staticExpressions';
 import { Symbol, SymbolFlags } from './symbol';
 import { isPrivateName } from './symbolNameUtils';
-import { EvaluatorFlags, FunctionArgument, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { EvalFlags, FunctionArgument, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
 import {
     AnyType,
     ClassType,
@@ -225,7 +225,7 @@ export function synthesizeDataClassMethods(
                 if (statement.rightExpression.nodeType === ParseNodeType.Call) {
                     const callTypeResult = evaluator.getTypeOfExpression(
                         statement.rightExpression.leftExpression,
-                        EvaluatorFlags.CallBaseDefaults
+                        EvalFlags.CallBaseDefaults
                     );
                     const callType = callTypeResult.type;
 
@@ -458,7 +458,7 @@ export function synthesizeDataClassMethods(
             if (statement.rightExpression.nodeType === ParseNodeType.Call) {
                 const callType = evaluator.getTypeOfExpression(
                     statement.rightExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 ).type;
 
                 if (
diff --git a/packages/pyright-internal/src/analyzer/decorators.ts b/packages/pyright-internal/src/analyzer/decorators.ts
index bc30588ef..e3739cd4a 100644
--- a/packages/pyright-internal/src/analyzer/decorators.ts
+++ b/packages/pyright-internal/src/analyzer/decorators.ts
@@ -33,7 +33,7 @@ import {
     createProperty,
     validatePropertyMethod,
 } from './properties';
-import { EvaluatorFlags, FunctionArgument, TypeEvaluator } from './typeEvaluatorTypes';
+import { EvalFlags, FunctionArgument, TypeEvaluator } from './typeEvaluatorTypes';
 import { isPartlyUnknown, isProperty } from './typeUtils';
 import {
     ClassType,
@@ -85,9 +85,9 @@ export function getFunctionInfoFromDecorators(
 
     for (const decoratorNode of node.decorators) {
         // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-        let evaluatorFlags = fileInfo.isStubFile ? EvaluatorFlags.AllowForwardReferences : EvaluatorFlags.None;
+        let evaluatorFlags = fileInfo.isStubFile ? EvalFlags.ForwardRefs : EvalFlags.None;
         if (decoratorNode.expression.nodeType !== ParseNodeType.Call) {
-            evaluatorFlags |= EvaluatorFlags.CallBaseDefaults;
+            evaluatorFlags |= EvalFlags.CallBaseDefaults;
         }
 
         const decoratorTypeResult = evaluator.getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
@@ -143,9 +143,9 @@ export function applyFunctionDecorator(
     const fileInfo = getFileInfo(decoratorNode);
 
     // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-    let evaluatorFlags = fileInfo.isStubFile ? EvaluatorFlags.AllowForwardReferences : EvaluatorFlags.None;
+    let evaluatorFlags = fileInfo.isStubFile ? EvalFlags.ForwardRefs : EvalFlags.None;
     if (decoratorNode.expression.nodeType !== ParseNodeType.Call) {
-        evaluatorFlags |= EvaluatorFlags.CallBaseDefaults;
+        evaluatorFlags |= EvalFlags.CallBaseDefaults;
     }
 
     const decoratorTypeResult = evaluator.getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
@@ -167,7 +167,7 @@ export function applyFunctionDecorator(
     if (decoratorNode.expression.nodeType === ParseNodeType.Call) {
         const decoratorCallType = evaluator.getTypeOfExpression(
             decoratorNode.expression.leftExpression,
-            evaluatorFlags | EvaluatorFlags.CallBaseDefaults
+            evaluatorFlags | EvalFlags.CallBaseDefaults
         ).type;
 
         if (isFunction(decoratorCallType)) {
@@ -201,7 +201,7 @@ export function applyFunctionDecorator(
         if (decoratorNode.expression.nodeType === ParseNodeType.MemberAccess) {
             const baseType = evaluator.getTypeOfExpression(
                 decoratorNode.expression.leftExpression,
-                evaluatorFlags | EvaluatorFlags.MemberAccessBaseDefaults
+                evaluatorFlags | EvalFlags.MemberAccessBaseDefaults
             ).type;
 
             if (isProperty(baseType)) {
@@ -298,16 +298,16 @@ export function applyClassDecorator(
     decoratorNode: DecoratorNode
 ): Type {
     const fileInfo = getFileInfo(decoratorNode);
-    let flags = fileInfo.isStubFile ? EvaluatorFlags.AllowForwardReferences : EvaluatorFlags.None;
+    let flags = fileInfo.isStubFile ? EvalFlags.ForwardRefs : EvalFlags.None;
     if (decoratorNode.expression.nodeType !== ParseNodeType.Call) {
-        flags |= EvaluatorFlags.CallBaseDefaults;
+        flags |= EvalFlags.CallBaseDefaults;
     }
     const decoratorType = evaluator.getTypeOfExpression(decoratorNode.expression, flags).type;
 
     if (decoratorNode.expression.nodeType === ParseNodeType.Call) {
         const decoratorCallType = evaluator.getTypeOfExpression(
             decoratorNode.expression.leftExpression,
-            flags | EvaluatorFlags.CallBaseDefaults
+            flags | EvalFlags.CallBaseDefaults
         ).type;
 
         if (isFunction(decoratorCallType)) {
@@ -367,7 +367,7 @@ export function applyClassDecorator(
             callNode = decoratorNode.expression;
             const decoratorCallType = evaluator.getTypeOfExpression(
                 callNode.leftExpression,
-                flags | EvaluatorFlags.CallBaseDefaults
+                flags | EvalFlags.CallBaseDefaults
             ).type;
             dataclassBehaviors = getDataclassDecoratorBehaviors(decoratorCallType);
         } else {
@@ -391,9 +391,9 @@ export function applyClassDecorator(
 
 function getTypeOfDecorator(evaluator: TypeEvaluator, node: DecoratorNode, functionOrClassType: Type): Type {
     // Evaluate the type of the decorator expression.
-    let flags = getFileInfo(node).isStubFile ? EvaluatorFlags.AllowForwardReferences : EvaluatorFlags.None;
+    let flags = getFileInfo(node).isStubFile ? EvalFlags.ForwardRefs : EvalFlags.None;
     if (node.expression.nodeType !== ParseNodeType.Call) {
-        flags |= EvaluatorFlags.CallBaseDefaults;
+        flags |= EvalFlags.CallBaseDefaults;
     }
 
     const decoratorTypeResult = evaluator.getTypeOfExpression(node.expression, flags);
diff --git a/packages/pyright-internal/src/analyzer/enums.ts b/packages/pyright-internal/src/analyzer/enums.ts
index 68ef3d23e..13986ff53 100644
--- a/packages/pyright-internal/src/analyzer/enums.ts
+++ b/packages/pyright-internal/src/analyzer/enums.ts
@@ -14,7 +14,7 @@ import { VariableDeclaration } from './declaration';
 import { getClassFullName, getEnclosingClass, getTypeSourceId } from './parseTreeUtils';
 import { Symbol, SymbolFlags } from './symbol';
 import { isPrivateName, isSingleDunderName } from './symbolNameUtils';
-import { EvaluatorFlags, FunctionArgument, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { EvalFlags, FunctionArgument, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
 import { enumerateLiteralsForType } from './typeGuards';
 import { MemberAccessFlags, computeMroLinearization, lookUpClassMember, makeInferenceContext } from './typeUtils';
 import {
@@ -369,7 +369,7 @@ export function transformTypeForEnumMember(
     let assignedType: Type | undefined;
 
     if (valueTypeExprNode) {
-        const evalFlags = getFileInfo(valueTypeExprNode).isStubFile ? EvaluatorFlags.ConvertEllipsisToAny : undefined;
+        const evalFlags = getFileInfo(valueTypeExprNode).isStubFile ? EvalFlags.ConvertEllipsisToAny : undefined;
         assignedType = evaluator.getTypeOfExpression(valueTypeExprNode, evalFlags).type;
     }
 
diff --git a/packages/pyright-internal/src/analyzer/operations.ts b/packages/pyright-internal/src/analyzer/operations.ts
index 1d03d957b..2db866226 100644
--- a/packages/pyright-internal/src/analyzer/operations.ts
+++ b/packages/pyright-internal/src/analyzer/operations.ts
@@ -25,7 +25,7 @@ import { getFileInfo } from './analyzerNodeInfo';
 import { getEnclosingLambda, isWithinLoop, operatorSupportsChaining, printOperator } from './parseTreeUtils';
 import { getScopeForNode } from './scopeUtils';
 import { evaluateStaticBoolExpression } from './staticExpressions';
-import { EvaluatorFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { EvalFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
 import {
     InferenceContext,
     convertToInstantiable,
@@ -501,7 +501,7 @@ export function validateBinaryOperation(
 export function getTypeOfBinaryOperation(
     evaluator: TypeEvaluator,
     node: BinaryOperationNode,
-    flags: EvaluatorFlags,
+    flags: EvalFlags,
     inferenceContext: InferenceContext | undefined
 ): TypeResult {
     const leftExpression = node.leftExpression;
@@ -622,7 +622,7 @@ export function getTypeOfBinaryOperation(
             const fileInfo = getFileInfo(node);
             const unionNotationSupported =
                 fileInfo.isStubFile ||
-                (flags & EvaluatorFlags.AllowForwardReferences) !== 0 ||
+                (flags & EvalFlags.ForwardRefs) !== 0 ||
                 fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion3_10);
 
             if (!unionNotationSupported) {
@@ -648,12 +648,12 @@ export function getTypeOfBinaryOperation(
             adjustedLeftType = evaluator.reportMissingTypeArguments(
                 node.leftExpression,
                 adjustedLeftType,
-                flags | EvaluatorFlags.ExpectingInstantiableType
+                flags | EvalFlags.InstantiableType
             );
             adjustedRightType = evaluator.reportMissingTypeArguments(
                 node.rightExpression,
                 adjustedRightType,
-                flags | EvaluatorFlags.ExpectingInstantiableType
+                flags | EvalFlags.InstantiableType
             );
 
             let newUnion = combineTypes([adjustedLeftType, adjustedRightType]);
@@ -703,7 +703,7 @@ export function getTypeOfBinaryOperation(
         }
     }
 
-    if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+    if ((flags & EvalFlags.TypeExpression) !== 0) {
         // Exempt "|" because it might be a union operation involving unknowns.
         if (node.operator !== OperatorType.BitwiseOr) {
             evaluator.addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.binaryOperationNotAllowed(), node);
@@ -947,10 +947,10 @@ export function getTypeOfAugmentedAssignment(
 export function getTypeOfUnaryOperation(
     evaluator: TypeEvaluator,
     node: UnaryOperationNode,
-    flags: EvaluatorFlags,
+    flags: EvalFlags,
     inferenceContext: InferenceContext | undefined
 ): TypeResult {
-    if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+    if ((flags & EvalFlags.TypeExpression) !== 0) {
         evaluator.addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.unaryOperationNotAllowed(), node);
         return { type: UnknownType.create() };
     }
@@ -1082,12 +1082,12 @@ export function getTypeOfUnaryOperation(
 export function getTypeOfTernaryOperation(
     evaluator: TypeEvaluator,
     node: TernaryNode,
-    flags: EvaluatorFlags,
+    flags: EvalFlags,
     inferenceContext: InferenceContext | undefined
 ): TypeResult {
     const fileInfo = getFileInfo(node);
 
-    if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+    if ((flags & EvalFlags.TypeExpression) !== 0) {
         evaluator.addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.ternaryNotAllowed(), node);
         return { type: UnknownType.create() };
     }
diff --git a/packages/pyright-internal/src/analyzer/patternMatching.ts b/packages/pyright-internal/src/analyzer/patternMatching.ts
index c943b8e25..3c6a4cc67 100644
--- a/packages/pyright-internal/src/analyzer/patternMatching.ts
+++ b/packages/pyright-internal/src/analyzer/patternMatching.ts
@@ -31,7 +31,7 @@ import {
 import { CodeFlowReferenceExpressionNode } from './codeFlowTypes';
 import { addConstraintsForExpectedType } from './constraintSolver';
 import { getTypeVarScopesForNode, isMatchingExpression } from './parseTreeUtils';
-import { EvaluatorFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { EvalFlags, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
 import {
     enumerateLiteralsForType,
     narrowTypeForDiscriminatedDictEntryComparison,
@@ -679,7 +679,7 @@ function narrowTypeBasedOnClassPattern(
     pattern: PatternClassNode,
     isPositiveTest: boolean
 ): Type {
-    let exprType = evaluator.getTypeOfExpression(pattern.className, EvaluatorFlags.CallBaseDefaults).type;
+    let exprType = evaluator.getTypeOfExpression(pattern.className, EvalFlags.CallBaseDefaults).type;
 
     // If this is a class (but not a type alias that refers to a class),
     // specialize it with Unknown type arguments.
@@ -1829,7 +1829,7 @@ function wrapTypeInList(evaluator: TypeEvaluator, node: ParseNode, type: Type):
 }
 
 export function validateClassPattern(evaluator: TypeEvaluator, pattern: PatternClassNode) {
-    let exprType = evaluator.getTypeOfExpression(pattern.className, EvaluatorFlags.CallBaseDefaults).type;
+    let exprType = evaluator.getTypeOfExpression(pattern.className, EvalFlags.CallBaseDefaults).type;
 
     // If the expression is a type alias or other special form, treat it
     // as the special form rather than the class.
@@ -1931,7 +1931,7 @@ export function getPatternSubtypeNarrowingCallback(
             if (ClassType.isBuiltIn(indexType, ['int', 'str'])) {
                 const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(
                     subjectExpression.baseExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const unnarrowedReferenceType = unnarrowedReferenceTypeResult.type;
 
@@ -2027,7 +2027,7 @@ export function getPatternSubtypeNarrowingCallback(
     ) {
         const unnarrowedReferenceTypeResult = evaluator.getTypeOfExpression(
             subjectExpression.leftExpression,
-            EvaluatorFlags.CallBaseDefaults
+            EvalFlags.CallBaseDefaults
         );
         const unnarrowedReferenceType = unnarrowedReferenceTypeResult.type;
 
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
index 95b8cdde9..f333f3a9b 100644
--- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts
+++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -176,7 +176,7 @@ import {
     ClassTypeResult,
     DeclaredSymbolTypeInfo,
     EffectiveTypeResult,
-    EvaluatorFlags,
+    EvalFlags,
     EvaluatorUsage,
     ExpectedTypeOptions,
     ExpectedTypeResult,
@@ -569,7 +569,7 @@ interface DeferredClassCompletion {
 interface TypeCacheEntry {
     typeResult: TypeResult;
     incompleteGenerationCount: number;
-    flags: EvaluatorFlags | undefined;
+    flags: EvalFlags | undefined;
 }
 
 interface CodeFlowAnalyzerCacheEntry {
@@ -678,7 +678,7 @@ export function createTypeEvaluator(
         );
     }
 
-    function readTypeCache(node: ParseNode, flags: EvaluatorFlags | undefined): Type | undefined {
+    function readTypeCache(node: ParseNode, flags: EvalFlags | undefined): Type | undefined {
         const cacheEntry = readTypeCacheEntry(node);
         if (!cacheEntry || cacheEntry.typeResult.isIncomplete) {
             return undefined;
@@ -712,7 +712,7 @@ export function createTypeEvaluator(
     function writeTypeCache(
         node: ParseNode,
         typeResult: TypeResult,
-        flags: EvaluatorFlags | undefined,
+        flags: EvalFlags | undefined,
         inferenceContext?: InferenceContext,
         allowSpeculativeCaching = false
     ) {
@@ -750,7 +750,7 @@ export function createTypeEvaluator(
         }
     }
 
-    function setTypeResultForNode(node: ParseNode, typeResult: TypeResult, flags = EvaluatorFlags.None) {
+    function setTypeResultForNode(node: ParseNode, typeResult: TypeResult, flags = EvalFlags.None) {
         writeTypeCache(node, typeResult, flags);
     }
 
@@ -895,7 +895,7 @@ export function createTypeEvaluator(
 
     // Reads the type of the node from the cache.
     function getCachedType(node: ExpressionNode | DecoratorNode): Type | undefined {
-        return readTypeCache(node, EvaluatorFlags.None);
+        return readTypeCache(node, EvalFlags.None);
     }
 
     // Determines the expected type of a specified node based on surrounding
@@ -1001,7 +1001,7 @@ export function createTypeEvaluator(
 
     function getTypeOfExpression(
         node: ExpressionNode,
-        flags = EvaluatorFlags.None,
+        flags = EvalFlags.None,
         inferenceContext?: InferenceContext,
         signatureTracker?: UniqueSignatureTracker
     ): TypeResult {
@@ -1135,12 +1135,12 @@ export function createTypeEvaluator(
     // This is a helper function that implements the core of getTypeOfExpression.
     function getTypeOfExpressionCore(
         node: ExpressionNode,
-        flags = EvaluatorFlags.None,
+        flags = EvalFlags.None,
         inferenceContext?: InferenceContext,
         signatureTracker?: UniqueSignatureTracker
     ): TypeResult {
         let typeResult: TypeResult | undefined;
-        let expectingInstantiable = (flags & EvaluatorFlags.ExpectingInstantiableType) !== 0;
+        let expectingInstantiable = (flags & EvalFlags.InstantiableType) !== 0;
 
         switch (node.nodeType) {
             case ParseNodeType.Name: {
@@ -1174,8 +1174,7 @@ export function createTypeEvaluator(
             }
 
             case ParseNodeType.StringList: {
-                const isExpectingType =
-                    (flags & EvaluatorFlags.EvaluateStringLiteralAsType) !== 0 && !isAnnotationLiteralValue(node);
+                const isExpectingType = (flags & EvalFlags.StrLiteralAsType) !== 0 && !isAnnotationLiteralValue(node);
 
                 if (isExpectingType) {
                     // Don't report expecting type errors again. We will have already
@@ -1208,7 +1207,7 @@ export function createTypeEvaluator(
                 // 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 !== OperatorType.BitwiseOr) {
-                    effectiveFlags &= ~EvaluatorFlags.ExpectingInstantiableType;
+                    effectiveFlags &= ~EvalFlags.InstantiableType;
                 }
 
                 typeResult = getTypeOfBinaryOperation(evaluatorInterface, node, effectiveFlags, inferenceContext);
@@ -1269,7 +1268,7 @@ export function createTypeEvaluator(
             }
 
             case ParseNodeType.AssignmentExpression: {
-                if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+                if ((flags & EvalFlags.TypeExpression) !== 0) {
                     addError(LocMessage.walrusNotAllowed(), node);
                 }
 
@@ -1296,12 +1295,12 @@ export function createTypeEvaluator(
             case ParseNodeType.TypeAnnotation: {
                 typeResult = getTypeOfExpression(
                     node.typeAnnotation,
-                    EvaluatorFlags.ExpectingInstantiableType |
-                        EvaluatorFlags.ExpectingTypeExpression |
-                        EvaluatorFlags.EvaluateStringLiteralAsType |
-                        EvaluatorFlags.DisallowParamSpec |
-                        EvaluatorFlags.DisallowTypeVarTuple |
-                        EvaluatorFlags.VariableTypeAnnotation
+                    EvalFlags.InstantiableType |
+                        EvalFlags.TypeExpression |
+                        EvalFlags.StrLiteralAsType |
+                        EvalFlags.NoParamSpec |
+                        EvalFlags.NoTypeVarTuple |
+                        EvalFlags.VarTypeAnnotation
                 );
                 break;
             }
@@ -1340,7 +1339,7 @@ export function createTypeEvaluator(
 
         // 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 & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+        if ((flags & EvalFlags.TypeExpression) !== 0) {
             if (typeResult.type.specialForm && ClassType.isBuiltIn(typeResult.type.specialForm, 'TypeAliasType')) {
                 typeResult.type = TypeBase.cloneAsSpecialForm(typeResult.type, undefined);
             }
@@ -1376,13 +1375,13 @@ export function createTypeEvaluator(
         }
     }
 
-    function validateTypeIsInstantiable(typeResult: TypeResult, flags: EvaluatorFlags, node: ExpressionNode) {
+    function validateTypeIsInstantiable(typeResult: TypeResult, flags: EvalFlags, node: ExpressionNode) {
         // If the type is incomplete, don't log any diagnostics yet.
         if (typeResult.isIncomplete) {
             return;
         }
 
-        if (flags & EvaluatorFlags.DisallowTypeVarTuple) {
+        if (flags & EvalFlags.NoTypeVarTuple) {
             if (isVariadicTypeVar(typeResult.type) && !typeResult.type.isVariadicInUnion) {
                 addError(LocMessage.typeVarTupleContext(), node);
                 typeResult.type = UnknownType.create();
@@ -1406,8 +1405,8 @@ export function createTypeEvaluator(
         }
     }
 
-    function getTypeOfAwaitOperator(node: AwaitNode, flags: EvaluatorFlags, inferenceContext?: InferenceContext) {
-        if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+    function getTypeOfAwaitOperator(node: AwaitNode, flags: EvalFlags, inferenceContext?: InferenceContext) {
+        if ((flags & EvalFlags.TypeExpression) !== 0) {
             addError(LocMessage.awaitNotAllowed(), node);
             return { type: UnknownType.create() };
         }
@@ -1434,8 +1433,8 @@ export function createTypeEvaluator(
         return typeResult;
     }
 
-    function getTypeOfEllipsis(flags: EvaluatorFlags, typeResult: TypeResult | undefined, node: ExpressionNode) {
-        if ((flags & EvaluatorFlags.ConvertEllipsisToAny) !== 0) {
+    function getTypeOfEllipsis(flags: EvalFlags, typeResult: TypeResult | undefined, node: ExpressionNode) {
+        if ((flags & EvalFlags.ConvertEllipsisToAny) !== 0) {
             typeResult = { type: AnyType.create(/* isEllipsis */ true) };
         } else {
             const ellipsisType =
@@ -1456,7 +1455,7 @@ export function createTypeEvaluator(
         return typeResult;
     }
 
-    function getTypeOfUnpackOperator(node: UnpackNode, flags: EvaluatorFlags, inferenceContext?: InferenceContext) {
+    function getTypeOfUnpackOperator(node: UnpackNode, flags: EvalFlags, inferenceContext?: InferenceContext) {
         let typeResult: TypeResult | undefined;
         let iterExpectedType: Type | undefined;
 
@@ -1475,19 +1474,15 @@ export function createTypeEvaluator(
 
         const iterTypeResult = getTypeOfExpression(node.expression, flags, makeInferenceContext(iterExpectedType));
         const iterType = iterTypeResult.type;
-        if (
-            (flags & EvaluatorFlags.DisallowTypeVarTuple) === 0 &&
-            isVariadicTypeVar(iterType) &&
-            !iterType.isVariadicUnpacked
-        ) {
+        if ((flags & EvalFlags.NoTypeVarTuple) === 0 && isVariadicTypeVar(iterType) && !iterType.isVariadicUnpacked) {
             typeResult = { type: TypeVarType.cloneForUnpacked(iterType) };
         } else if (
-            (flags & EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple) !== 0 &&
+            (flags & EvalFlags.AllowUnpackedTuple) !== 0 &&
             isInstantiableClass(iterType) &&
             ClassType.isBuiltIn(iterType, 'tuple')
         ) {
             typeResult = { type: ClassType.cloneForUnpacked(iterType) };
-        } else if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+        } else if ((flags & EvalFlags.TypeExpression) !== 0) {
             addError(LocMessage.unpackInAnnotation(), node, node.starToken);
             typeResult = { type: UnknownType.create() };
         } else {
@@ -1506,16 +1501,16 @@ export function createTypeEvaluator(
         return typeResult;
     }
 
-    function getTypeOfStringList(node: StringListNode, flags: EvaluatorFlags, isExpectingType: boolean) {
+    function getTypeOfStringList(node: StringListNode, flags: EvalFlags, isExpectingType: boolean) {
         let typeResult: TypeResult | undefined;
 
         if (isExpectingType) {
-            let updatedFlags = flags | EvaluatorFlags.AllowForwardReferences | EvaluatorFlags.ExpectingInstantiableType;
+            let updatedFlags = flags | EvalFlags.ForwardRefs | 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 & EvaluatorFlags.InterpreterParsesStringLiteral) === 0) {
-                updatedFlags |= EvaluatorFlags.NotParsedByInterpreter;
+            if ((flags & EvalFlags.ParsesStringLiteral) === 0) {
+                updatedFlags |= EvalFlags.NotParsed;
             }
 
             if (node.typeAnnotation) {
@@ -1728,68 +1723,68 @@ export function createTypeEvaluator(
         }
 
         let evaluatorFlags =
-            EvaluatorFlags.ExpectingInstantiableType |
-            EvaluatorFlags.ExpectingTypeExpression |
-            EvaluatorFlags.ConvertEllipsisToAny |
-            EvaluatorFlags.EvaluateStringLiteralAsType;
+            EvalFlags.InstantiableType |
+            EvalFlags.TypeExpression |
+            EvalFlags.ConvertEllipsisToAny |
+            EvalFlags.StrLiteralAsType;
 
         if (options?.isVariableAnnotation) {
-            evaluatorFlags |= EvaluatorFlags.VariableTypeAnnotation;
+            evaluatorFlags |= EvalFlags.VarTypeAnnotation;
         }
 
         if (!options?.allowFinal) {
-            evaluatorFlags |= EvaluatorFlags.DisallowFinal;
+            evaluatorFlags |= EvalFlags.NoFinal;
         }
 
         if (!options?.allowClassVar) {
-            evaluatorFlags |= EvaluatorFlags.DisallowClassVar;
+            evaluatorFlags |= EvalFlags.NoClassVar;
         }
 
         if (!options?.allowTypeVarTuple) {
-            evaluatorFlags |= EvaluatorFlags.DisallowTypeVarTuple;
+            evaluatorFlags |= EvalFlags.NoTypeVarTuple;
         } else {
-            evaluatorFlags |= EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple;
+            evaluatorFlags |= EvalFlags.AllowUnpackedTuple;
         }
 
         if (!options?.allowParamSpec) {
-            evaluatorFlags |= EvaluatorFlags.DisallowParamSpec;
+            evaluatorFlags |= EvalFlags.NoParamSpec;
         }
 
         if (options?.associateTypeVarsWithScope) {
-            evaluatorFlags |= EvaluatorFlags.AssociateTypeVarsWithCurrentScope;
+            evaluatorFlags |= EvalFlags.TypeVarGetsCurScope;
         }
 
         if (options?.allowUnpackedTypedDict) {
-            evaluatorFlags |= EvaluatorFlags.AllowUnpackedTypedDict;
+            evaluatorFlags |= EvalFlags.AllowUnpackedTypedDict;
         }
 
         if (options?.allowUnpackedTuple) {
-            evaluatorFlags |= EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple;
+            evaluatorFlags |= EvalFlags.AllowUnpackedTuple;
         }
 
         if (options?.notParsedByInterpreter) {
-            evaluatorFlags |= EvaluatorFlags.NotParsedByInterpreter;
+            evaluatorFlags |= EvalFlags.NotParsed;
         }
 
         if (options?.allowRequired) {
-            evaluatorFlags |= EvaluatorFlags.AllowRequired;
+            evaluatorFlags |= EvalFlags.AllowRequired;
         }
 
         if (isAnnotationEvaluationPostponed(fileInfo)) {
-            evaluatorFlags |= EvaluatorFlags.AllowForwardReferences;
+            evaluatorFlags |= EvalFlags.ForwardRefs;
         }
 
         // If the annotation is part of a comment, allow forward references
         // even if it's not enclosed in quotes.
         if (node?.parent?.nodeType === ParseNodeType.Assignment && node.parent.typeAnnotationComment === node) {
-            evaluatorFlags |= EvaluatorFlags.AllowForwardReferences | EvaluatorFlags.NotParsedByInterpreter;
+            evaluatorFlags |= EvalFlags.ForwardRefs | EvalFlags.NotParsed;
         } else if (node?.parent?.nodeType === ParseNodeType.FunctionAnnotation) {
             if (node.parent.returnTypeAnnotation === node || node.parent.paramTypeAnnotations.some((n) => n === node)) {
-                evaluatorFlags |= EvaluatorFlags.AllowForwardReferences | EvaluatorFlags.NotParsedByInterpreter;
+                evaluatorFlags |= EvalFlags.ForwardRefs | EvalFlags.NotParsed;
             }
         } else if (node?.parent?.nodeType === ParseNodeType.Parameter) {
             if (node.parent.typeAnnotationComment === node) {
-                evaluatorFlags |= EvaluatorFlags.AllowForwardReferences | EvaluatorFlags.NotParsedByInterpreter;
+                evaluatorFlags |= EvalFlags.ForwardRefs | EvalFlags.NotParsed;
             }
         }
 
@@ -2598,7 +2593,7 @@ export function createTypeEvaluator(
 
             case ParseNodeType.MemberAccess: {
                 const baseType = makeTopLevelTypeVarsConcrete(
-                    getTypeOfExpression(expression.leftExpression, EvaluatorFlags.MemberAccessBaseDefaults).type
+                    getTypeOfExpression(expression.leftExpression, EvalFlags.MemberAccessBaseDefaults).type
                 );
                 let classMemberInfo: ClassMember | undefined;
 
@@ -2636,7 +2631,7 @@ export function createTypeEvaluator(
 
             case ParseNodeType.Index: {
                 const baseType = makeTopLevelTypeVarsConcrete(
-                    getTypeOfExpression(expression.baseExpression, EvaluatorFlags.IndexBaseDefaults).type
+                    getTypeOfExpression(expression.baseExpression, EvalFlags.IndexBaseDefaults).type
                 );
 
                 if (baseType && isClassInstance(baseType)) {
@@ -3436,7 +3431,7 @@ export function createTypeEvaluator(
             );
         }
 
-        writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, EvaluatorFlags.None);
+        writeTypeCache(nameNode, { type: destType, isIncomplete: typeResult.isIncomplete }, EvalFlags.None);
     }
 
     function assignTypeToMemberAccessNode(
@@ -3445,7 +3440,7 @@ export function createTypeEvaluator(
         srcExpr?: ExpressionNode,
         expectedTypeDiagAddendum?: DiagnosticAddendum
     ) {
-        const baseTypeResult = getTypeOfExpression(target.leftExpression, EvaluatorFlags.MemberAccessBaseDefaults);
+        const baseTypeResult = getTypeOfExpression(target.leftExpression, EvalFlags.MemberAccessBaseDefaults);
         const baseType = makeTopLevelTypeVarsConcrete(baseTypeResult.type);
 
         // Handle member accesses (e.g. self.x or cls.y).
@@ -3495,7 +3490,7 @@ export function createTypeEvaluator(
                 setErrorNode: srcExpr,
                 setExpectedTypeDiag: expectedTypeDiagAddendum,
             },
-            EvaluatorFlags.None
+            EvalFlags.None
         );
 
         if (setTypeResult.isAsymmetricAccessor) {
@@ -3507,8 +3502,8 @@ export function createTypeEvaluator(
             isIncomplete: typeResult.isIncomplete,
             memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
         };
-        writeTypeCache(target.memberName, resultToCache, EvaluatorFlags.None);
-        writeTypeCache(target, resultToCache, EvaluatorFlags.None);
+        writeTypeCache(target.memberName, resultToCache, EvalFlags.None);
+        writeTypeCache(target, resultToCache, EvalFlags.None);
     }
 
     function assignTypeToMemberVariable(
@@ -3770,7 +3765,7 @@ export function createTypeEvaluator(
             );
         });
 
-        writeTypeCache(target, typeResult, EvaluatorFlags.None);
+        writeTypeCache(target, typeResult, EvalFlags.None);
     }
 
     // If the type includes promotion types, expand these to their constituent types.
@@ -4097,7 +4092,7 @@ export function createTypeEvaluator(
         // Is the source expression a TypeVar() call?
         if (isTypeVar(typeResult.type)) {
             if (srcExpr && srcExpr.nodeType === ParseNodeType.Call) {
-                const callType = getTypeOfExpression(srcExpr.leftExpression, EvaluatorFlags.CallBaseDefaults).type;
+                const callType = getTypeOfExpression(srcExpr.leftExpression, EvalFlags.CallBaseDefaults).type;
                 if (
                     isInstantiableClass(callType) &&
                     (ClassType.isBuiltIn(callType, 'TypeVar') ||
@@ -4151,7 +4146,7 @@ export function createTypeEvaluator(
             }
 
             case ParseNodeType.Index: {
-                const baseTypeResult = getTypeOfExpression(target.baseExpression, EvaluatorFlags.IndexBaseDefaults);
+                const baseTypeResult = getTypeOfExpression(target.baseExpression, EvalFlags.IndexBaseDefaults);
 
                 getTypeOfIndexWithBaseType(
                     target,
@@ -4162,10 +4157,10 @@ export function createTypeEvaluator(
                         setErrorNode: srcExpr,
                         setExpectedTypeDiag: expectedTypeDiagAddendum,
                     },
-                    EvaluatorFlags.None
+                    EvalFlags.None
                 );
 
-                writeTypeCache(target, typeResult, EvaluatorFlags.None);
+                writeTypeCache(target, typeResult, EvalFlags.None);
                 break;
             }
 
@@ -4343,29 +4338,26 @@ export function createTypeEvaluator(
             }
 
             case ParseNodeType.MemberAccess: {
-                const baseTypeResult = getTypeOfExpression(
-                    node.leftExpression,
-                    EvaluatorFlags.MemberAccessBaseDefaults
-                );
+                const baseTypeResult = getTypeOfExpression(node.leftExpression, EvalFlags.MemberAccessBaseDefaults);
                 const delAccessResult = getTypeOfMemberAccessWithBaseType(
                     node,
                     baseTypeResult,
                     { method: 'del' },
-                    EvaluatorFlags.None
+                    EvalFlags.None
                 );
                 const resultToCache: TypeResult = {
                     type: delAccessResult.type,
                     memberAccessDeprecationInfo: delAccessResult.memberAccessDeprecationInfo,
                 };
-                writeTypeCache(node.memberName, resultToCache, EvaluatorFlags.None);
-                writeTypeCache(node, resultToCache, EvaluatorFlags.None);
+                writeTypeCache(node.memberName, resultToCache, EvalFlags.None);
+                writeTypeCache(node, resultToCache, EvalFlags.None);
                 break;
             }
 
             case ParseNodeType.Index: {
-                const baseTypeResult = getTypeOfExpression(node.baseExpression, EvaluatorFlags.IndexBaseDefaults);
-                getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, EvaluatorFlags.None);
-                writeTypeCache(node, { type: UnboundType.create() }, EvaluatorFlags.None);
+                const baseTypeResult = getTypeOfExpression(node.baseExpression, EvalFlags.IndexBaseDefaults);
+                getTypeOfIndexWithBaseType(node, baseTypeResult, { method: 'del' }, EvalFlags.None);
+                writeTypeCache(node, { type: UnboundType.create() }, EvalFlags.None);
                 break;
             }
 
@@ -4400,13 +4392,13 @@ export function createTypeEvaluator(
         }
     }
 
-    function getTypeOfName(node: NameNode, flags: EvaluatorFlags): TypeResult {
+    function getTypeOfName(node: NameNode, flags: EvalFlags): TypeResult {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol: Symbol | undefined;
         let type: Type | undefined;
         let isIncomplete = false;
-        const allowForwardReferences = (flags & EvaluatorFlags.AllowForwardReferences) !== 0 || fileInfo.isStubFile;
+        const allowForwardReferences = (flags & EvalFlags.ForwardRefs) !== 0 || fileInfo.isStubFile;
 
         // Look for the scope that contains the value definition and
         // see if it has a declared type.
@@ -4414,7 +4406,7 @@ export function createTypeEvaluator(
             node,
             name,
             !allowForwardReferences,
-            allowForwardReferences && (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0
+            allowForwardReferences && (flags & EvalFlags.TypeExpression) !== 0
         );
 
         if (!symbolWithScope) {
@@ -4427,7 +4419,7 @@ export function createTypeEvaluator(
                     alias,
                     alias.value,
                     !allowForwardReferences,
-                    allowForwardReferences && (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0
+                    allowForwardReferences && (flags & EvalFlags.TypeExpression) !== 0
                 );
             }
         }
@@ -4520,7 +4512,7 @@ export function createTypeEvaluator(
                 const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                     targetSymbolId: symbol.id,
                     typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
-                    skipConditionalNarrowing: (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0,
+                    skipConditionalNarrowing: (flags & EvalFlags.TypeExpression) !== 0,
                 });
 
                 if (codeFlowTypeResult.type) {
@@ -4535,7 +4527,7 @@ export function createTypeEvaluator(
             // Detect, report, and fill in missing type arguments if appropriate.
             type = reportMissingTypeArguments(node, type, flags);
 
-            if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+            if ((flags & EvalFlags.TypeExpression) !== 0) {
                 // Verify that the name does not refer to a (non type alias) variable.
                 if (effectiveTypeInfo.includesVariableDecl && !type.typeAliasInfo) {
                     let isAllowedTypeForVariable = isTypeVar(type) || isTypeAliasPlaceholder(type);
@@ -4560,7 +4552,7 @@ export function createTypeEvaluator(
                         if (
                             effectiveTypeInfo.includesIllegalTypeAliasDecl ||
                             !TypeBase.isInstantiable(type) ||
-                            (flags & EvaluatorFlags.DoNotSpecialize) !== 0
+                            (flags & EvalFlags.NoSpecialize) !== 0
                         ) {
                             addDiagnostic(
                                 DiagnosticRule.reportInvalidTypeForm,
@@ -4588,7 +4580,7 @@ export function createTypeEvaluator(
         }
 
         if (isParamSpec(type)) {
-            if (flags & EvaluatorFlags.DisallowParamSpec) {
+            if (flags & EvalFlags.NoParamSpec) {
                 addError(LocMessage.paramSpecContext(), node);
                 type = UnknownType.create();
             }
@@ -4596,12 +4588,12 @@ export function createTypeEvaluator(
 
         type = convertSpecialFormToRuntimeValue(type, flags);
 
-        if ((flags & EvaluatorFlags.ExpectingTypeExpression) === 0) {
+        if ((flags & EvalFlags.TypeExpression) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
 
-        if ((flags & EvaluatorFlags.ExpectingInstantiableType) !== 0) {
-            if ((flags & EvaluatorFlags.AllowGenericClassType) === 0) {
+        if ((flags & EvalFlags.InstantiableType) !== 0) {
+            if ((flags & EvalFlags.AllowGeneric) === 0) {
                 if (isInstantiableClass(type) && ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(DiagnosticRule.reportGeneralTypeIssues, LocMessage.genericNotAllowed(), node);
                 }
@@ -4618,11 +4610,8 @@ export function createTypeEvaluator(
     // 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: Type, flags: EvaluatorFlags) {
-        const exemptFlags =
-            EvaluatorFlags.ExpectingTypeExpression |
-            EvaluatorFlags.ExpectingInstantiableType |
-            EvaluatorFlags.SkipConvertSpecialFormToRuntimeObject;
+    function convertSpecialFormToRuntimeValue(type: Type, flags: EvalFlags) {
+        const exemptFlags = EvalFlags.TypeExpression | EvalFlags.InstantiableType | EvalFlags.NoConvertSpecialForm;
 
         if ((flags & exemptFlags) !== 0) {
             return type;
@@ -4743,12 +4732,12 @@ export function createTypeEvaluator(
     // and provides a scope ID defined by its containing scope (class, function
     // or type alias). If not, it emits errors indicating why the TypeVar
     // cannot be used in this location.
-    function validateTypeVarUsage(node: ExpressionNode, type: TypeVarType, flags: EvaluatorFlags) {
+    function validateTypeVarUsage(node: ExpressionNode, type: TypeVarType, flags: EvalFlags) {
         if (TypeBase.isInstantiable(type) && !type.scopeId && !isTypeAliasPlaceholder(type)) {
             const scopedTypeVarInfo = findScopedTypeVar(node, type);
             type = scopedTypeVarInfo.type;
 
-            if ((flags & EvaluatorFlags.DisallowTypeVarsWithScopeId) !== 0 && type.scopeId !== undefined) {
+            if ((flags & 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.
@@ -4774,7 +4763,7 @@ export function createTypeEvaluator(
                         node
                     );
                 }
-            } else if ((flags & EvaluatorFlags.AssociateTypeVarsWithCurrentScope) !== 0) {
+            } else if ((flags & EvalFlags.TypeVarGetsCurScope) !== 0) {
                 if (type.scopeId === undefined) {
                     if (!scopedTypeVarInfo.foundInterveningClass) {
                         let enclosingScope = ParseTreeUtils.getEnclosingClassOrFunction(node);
@@ -4841,7 +4830,7 @@ export function createTypeEvaluator(
                         );
                     }
                 }
-            } else if ((flags & EvaluatorFlags.AllowTypeVarsWithoutScopeId) === 0) {
+            } else if ((flags & EvalFlags.AllowTypeVarWithoutScopeId) === 0) {
                 if (
                     (type.scopeId === undefined || scopedTypeVarInfo.foundInterveningClass) &&
                     !type.details.isSynthesized
@@ -4870,17 +4859,14 @@ export function createTypeEvaluator(
     // Determines if the type is a generic class or type alias with missing
     // type arguments. If so, it fills in these type arguments with Unknown
     // and optionally reports an error.
-    function reportMissingTypeArguments(node: ExpressionNode, type: Type, flags: EvaluatorFlags): Type {
-        if ((flags & EvaluatorFlags.DoNotSpecialize) !== 0) {
+    function reportMissingTypeArguments(node: ExpressionNode, type: Type, flags: EvalFlags): Type {
+        if ((flags & EvalFlags.NoSpecialize) !== 0) {
             return type;
         }
 
         // Is this a generic class that needs to be specialized?
         if (isInstantiableClass(type)) {
-            if (
-                (flags & EvaluatorFlags.ExpectingInstantiableType) !== 0 &&
-                (flags & EvaluatorFlags.AllowMissingTypeArgs) === 0
-            ) {
+            if ((flags & EvalFlags.InstantiableType) !== 0 && (flags & EvalFlags.AllowMissingTypeArgs) === 0) {
                 if (!type.typeAliasInfo && requiresTypeArguments(type)) {
                     if (!type.typeArguments || !type.isTypeArgumentExplicit) {
                         addDiagnostic(
@@ -4901,7 +4887,7 @@ export function createTypeEvaluator(
 
         // Is this a generic type alias that needs to be specialized?
         if (
-            (flags & EvaluatorFlags.ExpectingInstantiableType) !== 0 &&
+            (flags & EvalFlags.InstantiableType) !== 0 &&
             type.typeAliasInfo &&
             type.typeAliasInfo.typeParameters &&
             type.typeAliasInfo.typeParameters.length > 0 &&
@@ -5024,10 +5010,10 @@ export function createTypeEvaluator(
             let typeAliasNode: TypeAliasNode | undefined = undefined;
 
             if (curNode.nodeType === ParseNodeType.TypeAlias) {
-                leftType = readTypeCache(curNode.name, EvaluatorFlags.None);
+                leftType = readTypeCache(curNode.name, EvalFlags.None);
                 typeAliasNode = curNode;
             } else if (curNode.nodeType === ParseNodeType.Assignment) {
-                leftType = readTypeCache(curNode.leftExpression, EvaluatorFlags.None);
+                leftType = readTypeCache(curNode.leftExpression, EvalFlags.None);
             }
 
             if (leftType) {
@@ -5081,23 +5067,23 @@ export function createTypeEvaluator(
         return { type, foundInterveningClass: false };
     }
 
-    function getTypeOfMemberAccess(node: MemberAccessNode, flags: EvaluatorFlags): TypeResult {
+    function getTypeOfMemberAccess(node: MemberAccessNode, flags: EvalFlags): TypeResult {
         // Compute flags specifically for evaluating the left expression.
-        let leftExprFlags = EvaluatorFlags.MemberAccessBaseDefaults;
+        let leftExprFlags = EvalFlags.MemberAccessBaseDefaults;
         leftExprFlags |=
             flags &
-            (EvaluatorFlags.ExpectingTypeExpression |
-                EvaluatorFlags.VariableTypeAnnotation |
-                EvaluatorFlags.AllowForwardReferences |
-                EvaluatorFlags.NotParsedByInterpreter |
-                EvaluatorFlags.DisallowTypeVarsWithScopeId |
-                EvaluatorFlags.AssociateTypeVarsWithCurrentScope);
+            (EvalFlags.TypeExpression |
+                EvalFlags.VarTypeAnnotation |
+                EvalFlags.ForwardRefs |
+                EvalFlags.NotParsed |
+                EvalFlags.NoTypeVarWithScopeId |
+                EvalFlags.TypeVarGetsCurScope);
 
         // Handle special casing for ParamSpec "args" and "kwargs" accesses.
-        if ((flags & EvaluatorFlags.ExpectingInstantiableType) !== 0) {
+        if ((flags & EvalFlags.InstantiableType) !== 0) {
             const memberName = node.memberName.value;
             if (memberName === 'args' || memberName === 'kwargs') {
-                leftExprFlags |= EvaluatorFlags.SkipConvertSpecialFormToRuntimeObject;
+                leftExprFlags |= EvalFlags.NoConvertSpecialForm;
             }
         }
         const baseTypeResult = getTypeOfExpression(node.leftExpression, leftExprFlags);
@@ -5113,7 +5099,7 @@ export function createTypeEvaluator(
             node,
             baseTypeResult,
             { method: 'get' },
-            flags | EvaluatorFlags.DoNotSpecialize
+            flags | EvalFlags.NoSpecialize
         );
 
         if (isCodeFlowSupportedForReference(node)) {
@@ -5153,7 +5139,7 @@ export function createTypeEvaluator(
             const codeFlowTypeResult = getFlowTypeOfReference(node, /* startNode */ undefined, {
                 targetSymbolId: indeterminateSymbolId,
                 typeAtStart: { type: typeAtStart, isIncomplete: isTypeAtStartIncomplete },
-                skipConditionalNarrowing: (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0,
+                skipConditionalNarrowing: (flags & EvalFlags.TypeExpression) !== 0,
             });
 
             if (codeFlowTypeResult.type) {
@@ -5211,7 +5197,7 @@ export function createTypeEvaluator(
         node: MemberAccessNode,
         baseTypeResult: TypeResult,
         usage: EvaluatorUsage,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): TypeResult {
         let baseType = transformPossibleRecursiveTypeAlias(baseTypeResult.type);
         const memberName = node.memberName.value;
@@ -5232,7 +5218,7 @@ export function createTypeEvaluator(
             return { type: UnknownType.create(/* isIncomplete */ true), isIncomplete: true };
         }
 
-        if (baseType.specialForm && (flags & EvaluatorFlags.ExpectingTypeExpression) === 0) {
+        if (baseType.specialForm && (flags & EvalFlags.TypeExpression) === 0) {
             baseType = baseType.specialForm;
         }
 
@@ -5286,7 +5272,7 @@ export function createTypeEvaluator(
                 }
 
                 // It's illegal to reference a member from a type variable.
-                if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+                if ((flags & EvalFlags.TypeExpression) !== 0) {
                     if (!isIncomplete) {
                         addDiagnostic(
                             DiagnosticRule.reportGeneralTypeIssues,
@@ -5320,7 +5306,7 @@ export function createTypeEvaluator(
                         isIncomplete,
                     },
                     usage,
-                    EvaluatorFlags.None
+                    EvalFlags.None
                 );
             }
 
@@ -5531,7 +5517,7 @@ export function createTypeEvaluator(
                             isIncomplete: baseTypeResult.isIncomplete,
                         },
                         usage,
-                        EvaluatorFlags.None
+                        EvalFlags.None
                     );
 
                     if (typeResult.isIncomplete) {
@@ -5630,7 +5616,7 @@ export function createTypeEvaluator(
             type = isFunctionRule ? AnyType.create() : UnknownType.create();
         }
 
-        if ((flags & EvaluatorFlags.ExpectingTypeExpression) === 0) {
+        if ((flags & EvalFlags.TypeExpression) === 0) {
             reportUseOfTypeCheckOnly(type, node.memberName);
         }
 
@@ -6437,24 +6423,24 @@ export function createTypeEvaluator(
         };
     }
 
-    function getTypeOfIndex(node: IndexNode, flags = EvaluatorFlags.None): TypeResult {
-        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | EvaluatorFlags.IndexBaseDefaults);
+    function getTypeOfIndex(node: IndexNode, flags = EvalFlags.None): TypeResult {
+        const baseTypeResult = getTypeOfExpression(node.baseExpression, flags | 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 & EvaluatorFlags.ExpectingInstantiableType) {
+        if (flags & EvalFlags.InstantiableType) {
             if (node.baseExpression.nodeType === ParseNodeType.StringList) {
                 addError(LocMessage.stringNotSubscriptable(), node.baseExpression);
             }
         }
 
         // Check for builtin classes that will generate runtime exceptions if subscripted.
-        if ((flags & EvaluatorFlags.AllowForwardReferences) === 0) {
+        if ((flags & 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 & EvaluatorFlags.VariableTypeAnnotation) !== 0;
+            let skipSubscriptCheck = (flags & EvalFlags.VarTypeAnnotation) !== 0;
             if (skipSubscriptCheck) {
                 const scopeNode = ParseTreeUtils.getExecutionScopeNode(node);
                 if (scopeNode?.nodeType === ParseNodeType.Module) {
@@ -6515,7 +6501,7 @@ export function createTypeEvaluator(
                         type: indexTypeResult.type,
                         isIncomplete: !!baseTypeResult.isIncomplete || !!indexTypeResult.isIncomplete,
                     },
-                    skipConditionalNarrowing: (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0,
+                    skipConditionalNarrowing: (flags & EvalFlags.TypeExpression) !== 0,
                 });
 
                 if (codeFlowTypeResult.type) {
@@ -6683,7 +6669,7 @@ export function createTypeEvaluator(
     function createSpecializedTypeAlias(
         node: IndexNode,
         baseType: Type,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): TypeResultWithNode | undefined {
         if (
             !baseType.typeAliasInfo?.typeParameters ||
@@ -6863,7 +6849,7 @@ export function createTypeEvaluator(
                     typeArgType = UnknownType.create();
                 }
 
-                if ((flags & EvaluatorFlags.EnforceTypeVarVarianceConsistency) !== 0) {
+                if ((flags & EvalFlags.EnforceVarianceConsistency) !== 0) {
                     const usageVariances = inferTypeParameterVarianceForTypeAlias(baseType);
                     if (usageVariances && index < usageVariances.length) {
                         const usageVariance = usageVariances[index];
@@ -6952,7 +6938,7 @@ export function createTypeEvaluator(
         node: IndexNode,
         baseTypeResult: TypeResult,
         usage: EvaluatorUsage,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): TypeResult {
         // Handle the case where we're specializing a generic type alias.
         const typeAliasResult = createSpecializedTypeAlias(node, baseTypeResult.type, flags);
@@ -6988,7 +6974,7 @@ export function createTypeEvaluator(
                 const selfType = isTypeVar(unexpandedSubtype) ? unexpandedSubtype : undefined;
 
                 if (isAnyOrUnknown(concreteSubtype)) {
-                    if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+                    if ((flags & EvalFlags.TypeExpression) !== 0) {
                         // If we are expecting a type annotation here, assume that
                         // the subscripts are type arguments and evaluate them
                         // accordingly.
@@ -6998,7 +6984,7 @@ export function createTypeEvaluator(
                     return concreteSubtype;
                 }
 
-                if (flags & EvaluatorFlags.ExpectingInstantiableType) {
+                if (flags & EvalFlags.InstantiableType) {
                     if (isTypeVar(unexpandedSubtype)) {
                         addDiagnostic(
                             DiagnosticRule.reportGeneralTypeIssues,
@@ -7021,14 +7007,14 @@ export function createTypeEvaluator(
                         concreteSubtype.details.effectiveMetaclass &&
                         isInstantiableClass(concreteSubtype.details.effectiveMetaclass) &&
                         !ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
-                        (flags & EvaluatorFlags.ExpectingInstantiableType) === 0
+                        (flags & EvalFlags.InstantiableType) === 0
                     ) {
                         const itemMethodType = getBoundMagicMethod(
                             concreteSubtype,
                             getIndexAccessMagicMethodName(usage)
                         );
 
-                        if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+                        if ((flags & EvalFlags.TypeExpression) !== 0) {
                             // If the class doesn't derive from Generic, a type argument should not be allowed.
                             addDiagnostic(
                                 DiagnosticRule.reportInvalidTypeArguments,
@@ -7069,8 +7055,8 @@ export function createTypeEvaluator(
                         // Special-case InitVar, used in dataclasses.
                         const typeArgs = getTypeArgs(node, flags);
 
-                        if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
-                            if ((flags & EvaluatorFlags.VariableTypeAnnotation) === 0) {
+                        if ((flags & EvalFlags.TypeExpression) !== 0) {
+                            if ((flags & EvalFlags.VarTypeAnnotation) === 0) {
                                 addError(LocMessage.initVarNotAllowed(), node.baseExpression);
                             }
                         }
@@ -7201,7 +7187,7 @@ export function createTypeEvaluator(
         if (!baseTypeResult.isIncomplete) {
             node.items.forEach((item) => {
                 if (!isTypeCached(item.valueExpression)) {
-                    getTypeOfExpression(item.valueExpression, flags & EvaluatorFlags.AllowForwardReferences);
+                    getTypeOfExpression(item.valueExpression, flags & EvalFlags.ForwardRefs);
                 }
             });
         }
@@ -7577,14 +7563,14 @@ export function createTypeEvaluator(
         return value;
     }
 
-    function getTypeArgs(node: IndexNode, flags: EvaluatorFlags, options?: GetTypeArgsOptions): TypeResultWithNode[] {
+    function getTypeArgs(node: IndexNode, flags: EvalFlags, options?: GetTypeArgsOptions): TypeResultWithNode[] {
         const typeArgs: TypeResultWithNode[] = [];
         let adjFlags = flags;
 
         if (options?.isFinalAnnotation) {
-            adjFlags |= EvaluatorFlags.DisallowClassVar | EvaluatorFlags.DisallowFinal;
+            adjFlags |= EvalFlags.NoClassVar | EvalFlags.NoFinal;
         } else if (options?.isClassVarAnnotation) {
-            adjFlags |= EvaluatorFlags.DisallowClassVar;
+            adjFlags |= 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,
@@ -7599,22 +7585,22 @@ export function createTypeEvaluator(
             }
 
             if (disallowFinal) {
-                adjFlags |= EvaluatorFlags.DisallowFinal;
+                adjFlags |= EvalFlags.NoFinal;
             }
         } else {
             adjFlags &= ~(
-                EvaluatorFlags.DoNotSpecialize |
-                EvaluatorFlags.DisallowParamSpec |
-                EvaluatorFlags.DisallowTypeVarTuple |
-                EvaluatorFlags.AllowRequired |
-                EvaluatorFlags.EnforceTypeVarVarianceConsistency
+                EvalFlags.NoSpecialize |
+                EvalFlags.NoParamSpec |
+                EvalFlags.NoTypeVarTuple |
+                EvalFlags.AllowRequired |
+                EvalFlags.EnforceVarianceConsistency
             );
 
             if (!options?.isAnnotatedClass) {
-                adjFlags |= EvaluatorFlags.DisallowClassVar | EvaluatorFlags.DisallowFinal;
+                adjFlags |= EvalFlags.NoClassVar | EvalFlags.NoFinal;
             }
 
-            adjFlags |= EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple | EvaluatorFlags.AllowConcatenate;
+            adjFlags |= EvalFlags.AllowUnpackedTuple | EvalFlags.AllowConcatenate;
         }
 
         // Create a local function that validates a single type argument.
@@ -7625,10 +7611,7 @@ export function createTypeEvaluator(
             // treated as types.
             if (options?.hasCustomClassGetItem) {
                 adjFlags =
-                    EvaluatorFlags.DisallowParamSpec |
-                    EvaluatorFlags.DisallowTypeVarTuple |
-                    EvaluatorFlags.DoNotSpecialize |
-                    EvaluatorFlags.DisallowClassVar;
+                    EvalFlags.NoParamSpec | EvalFlags.NoTypeVarTuple | EvalFlags.NoSpecialize | EvalFlags.NoClassVar;
                 typeResult = {
                     ...getTypeOfExpression(expr, adjFlags),
                     node: expr,
@@ -7637,12 +7620,9 @@ export function createTypeEvaluator(
                 // 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 =
-                    EvaluatorFlags.DisallowParamSpec |
-                    EvaluatorFlags.DisallowTypeVarTuple |
-                    EvaluatorFlags.DoNotSpecialize |
-                    EvaluatorFlags.DisallowClassVar;
+                    EvalFlags.NoParamSpec | EvalFlags.NoTypeVarTuple | EvalFlags.NoSpecialize | EvalFlags.NoClassVar;
                 if (isAnnotationEvaluationPostponed(AnalyzerNodeInfo.getFileInfo(node))) {
-                    adjFlags |= EvaluatorFlags.AllowForwardReferences;
+                    adjFlags |= EvalFlags.ForwardRefs;
                 }
 
                 typeResult = {
@@ -7703,18 +7683,15 @@ export function createTypeEvaluator(
         return typeArgs;
     }
 
-    function getTypeArg(node: ExpressionNode, flags: EvaluatorFlags): TypeResultWithNode {
+    function getTypeArg(node: ExpressionNode, flags: EvalFlags): TypeResultWithNode {
         let typeResult: TypeResultWithNode;
 
         let adjustedFlags =
-            flags |
-            EvaluatorFlags.ExpectingInstantiableType |
-            EvaluatorFlags.ConvertEllipsisToAny |
-            EvaluatorFlags.EvaluateStringLiteralAsType;
+            flags | EvalFlags.InstantiableType | EvalFlags.ConvertEllipsisToAny | EvalFlags.StrLiteralAsType;
 
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile) {
-            adjustedFlags |= EvaluatorFlags.AllowForwardReferences;
+            adjustedFlags |= EvalFlags.ForwardRefs;
         }
 
         if (node.nodeType === ParseNodeType.List) {
@@ -7735,7 +7712,7 @@ export function createTypeEvaluator(
                 addError(LocMessage.dictInAnnotation(), node);
             }
 
-            if ((flags & EvaluatorFlags.DisallowClassVar) !== 0) {
+            if ((flags & EvalFlags.NoClassVar) !== 0) {
                 // "ClassVar" is not allowed as a type argument.
                 if (isClass(typeResult.type) && ClassType.isBuiltIn(typeResult.type, 'ClassVar')) {
                     addError(LocMessage.classVarNotAllowed(), node);
@@ -7748,14 +7725,11 @@ export function createTypeEvaluator(
 
     function getTypeOfTuple(
         node: TupleNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext | undefined,
         signatureTracker: UniqueSignatureTracker | undefined
     ): TypeResult {
-        if (
-            (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0 &&
-            node.parent?.nodeType !== ParseNodeType.Argument
-        ) {
+        if ((flags & EvalFlags.TypeExpression) !== 0 && node.parent?.nodeType !== 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.
@@ -7770,19 +7744,11 @@ export function createTypeEvaluator(
             return { type: UnknownType.create() };
         }
 
-        if (
-            (flags & EvaluatorFlags.ExpectingInstantiableType) !== 0 &&
-            node.expressions.length === 0 &&
-            !inferenceContext
-        ) {
+        if ((flags & EvalFlags.InstantiableType) !== 0 && node.expressions.length === 0 && !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
 
-        flags &= ~(
-            EvaluatorFlags.ExpectingTypeExpression |
-            EvaluatorFlags.EvaluateStringLiteralAsType |
-            EvaluatorFlags.ExpectingInstantiableType
-        );
+        flags &= ~(EvalFlags.TypeExpression | EvalFlags.StrLiteralAsType | EvalFlags.InstantiableType);
 
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -7849,7 +7815,7 @@ export function createTypeEvaluator(
 
     function getTypeOfTupleWithContext(
         node: TupleNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext,
         signatureTracker: UniqueSignatureTracker | undefined
     ): TypeResult | undefined {
@@ -7908,7 +7874,7 @@ export function createTypeEvaluator(
         const entryTypeResults = node.expressions.map((expr, index) =>
             getTypeOfExpression(
                 expr,
-                flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                flags | EvalFlags.StripTupleLiterals,
                 makeInferenceContext(
                     index < expectedTypes.length ? expectedTypes[index] : undefined,
                     inferenceContext.isTypeIncomplete
@@ -7933,14 +7899,14 @@ export function createTypeEvaluator(
         return { type, expectedTypeDiagAddendum, isIncomplete };
     }
 
-    function getTypeOfTupleInferred(node: TupleNode, flags: EvaluatorFlags): TypeResult {
+    function getTypeOfTupleInferred(node: TupleNode, flags: EvalFlags): TypeResult {
         const entryTypeResults = node.expressions.map((expr) =>
-            getTypeOfExpression(expr, flags | EvaluatorFlags.StripLiteralTypeForTuple)
+            getTypeOfExpression(expr, flags | EvalFlags.StripTupleLiterals)
         );
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
 
         const type = makeTupleObject(
-            buildTupleTypesList(entryTypeResults, (flags & EvaluatorFlags.StripLiteralTypeForTuple) !== 0)
+            buildTupleTypesList(entryTypeResults, (flags & EvalFlags.StripTupleLiterals) !== 0)
         );
 
         if (isIncomplete) {
@@ -8001,7 +7967,7 @@ export function createTypeEvaluator(
 
     function getTypeOfCall(
         node: CallNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext | undefined,
         signatureTracker: UniqueSignatureTracker | undefined
     ): TypeResult {
@@ -8011,7 +7977,7 @@ export function createTypeEvaluator(
         // allowed, and it's a common mistake, so we want to emit a diagnostic
         // that guides the user to the right solution.
         if (
-            (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0 &&
+            (flags & EvalFlags.TypeExpression) !== 0 &&
             node.leftExpression.nodeType === ParseNodeType.Name &&
             node.leftExpression.value === 'type'
         ) {
@@ -8030,7 +7996,7 @@ export function createTypeEvaluator(
         } else {
             baseTypeResult = getTypeOfExpression(
                 node.leftExpression,
-                EvaluatorFlags.CallBaseDefaults | (flags & EvaluatorFlags.AllowForwardReferences)
+                EvalFlags.CallBaseDefaults | (flags & EvalFlags.ForwardRefs)
             );
         }
 
@@ -8139,7 +8105,7 @@ export function createTypeEvaluator(
             }
         }
 
-        if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+        if ((flags & EvalFlags.TypeExpression) !== 0) {
             addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.typeAnnotationCall(), node);
 
             typeResult = { type: UnknownType.create() };
@@ -8188,7 +8154,7 @@ export function createTypeEvaluator(
         function getLambdaType() {
             return getTypeOfExpression(
                 node.leftExpression,
-                EvaluatorFlags.CallBaseDefaults,
+                EvalFlags.CallBaseDefaults,
                 makeInferenceContext(expectedType)
             );
         }
@@ -8203,7 +8169,7 @@ export function createTypeEvaluator(
 
         // If bidirectional type inference failed, use normal type inference instead.
         if (typeResult.typeErrors) {
-            typeResult = getTypeOfExpression(node.leftExpression, EvaluatorFlags.CallBaseDefaults);
+            typeResult = getTypeOfExpression(node.leftExpression, EvalFlags.CallBaseDefaults);
         }
 
         return typeResult;
@@ -12073,13 +12039,13 @@ export function createTypeEvaluator(
                 argType = argParam.argType;
             } else {
                 const flags = argParam.isinstanceParam
-                    ? EvaluatorFlags.AllowMissingTypeArgs |
-                      EvaluatorFlags.EvaluateStringLiteralAsType |
-                      EvaluatorFlags.DisallowParamSpec |
-                      EvaluatorFlags.DisallowTypeVarTuple |
-                      EvaluatorFlags.DisallowFinal |
-                      EvaluatorFlags.DoNotSpecialize
-                    : EvaluatorFlags.DisallowFinal | EvaluatorFlags.DoNotSpecialize;
+                    ? EvalFlags.AllowMissingTypeArgs |
+                      EvalFlags.StrLiteralAsType |
+                      EvalFlags.NoParamSpec |
+                      EvalFlags.NoTypeVarTuple |
+                      EvalFlags.NoFinal |
+                      EvalFlags.NoSpecialize
+                    : EvalFlags.NoFinal | EvalFlags.NoSpecialize;
                 const exprTypeResult = getTypeOfExpression(
                     argParam.argument.valueExpression,
                     flags,
@@ -12122,7 +12088,7 @@ export function createTypeEvaluator(
                 writeTypeCache(
                     argParam.argument.name,
                     { type: expectedType ?? argType, isIncomplete: isTypeIncomplete },
-                    EvaluatorFlags.None
+                    EvalFlags.None
                 );
             }
         } else {
@@ -12856,7 +12822,7 @@ export function createTypeEvaluator(
             typeParamsExpr.expressions.map((expr) => {
                 let entryType = getTypeOfExpression(
                     expr,
-                    EvaluatorFlags.ExpectingInstantiableType | EvaluatorFlags.AllowTypeVarsWithoutScopeId
+                    EvalFlags.InstantiableType | EvalFlags.AllowTypeVarWithoutScopeId
                 ).type;
 
                 if (isTypeVar(entryType)) {
@@ -13125,15 +13091,12 @@ export function createTypeEvaluator(
         return classType;
     }
 
-    function getTypeOfConstant(node: ConstantNode, flags: EvaluatorFlags): TypeResult {
+    function getTypeOfConstant(node: ConstantNode, flags: EvalFlags): TypeResult {
         let type: Type | undefined;
 
         if (node.constType === KeywordType.None) {
             if (noneTypeClass) {
-                type =
-                    (flags & EvaluatorFlags.ExpectingInstantiableType) !== 0
-                        ? noneTypeClass
-                        : convertToInstance(noneTypeClass);
+                type = (flags & EvalFlags.InstantiableType) !== 0 ? noneTypeClass : convertToInstance(noneTypeClass);
             }
         } else if (
             node.constType === KeywordType.True ||
@@ -13262,13 +13225,10 @@ export function createTypeEvaluator(
 
     function getTypeOfDictionary(
         node: DictionaryNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext | undefined
     ): TypeResult {
-        if (
-            (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0 &&
-            node.parent?.nodeType !== ParseNodeType.Argument
-        ) {
+        if ((flags & EvalFlags.TypeExpression) !== 0 && node.parent?.nodeType !== ParseNodeType.Argument) {
             const diag = new DiagnosticAddendum();
             diag.addMessage(LocAddendum.useDictInstead());
             addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.dictInAnnotation() + diag.getString(), node);
@@ -13329,7 +13289,7 @@ export function createTypeEvaluator(
 
     function getTypeOfDictionaryWithContext(
         node: DictionaryNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext,
         expectedDiagAddendum?: DiagnosticAddendum
     ): TypeResult | undefined {
@@ -13487,11 +13447,7 @@ export function createTypeEvaluator(
 
     // Attempts to infer the type of a dictionary statement. If hasExpectedType
     // is true, strict inference is used for the subexpressions.
-    function getTypeOfDictionaryInferred(
-        node: DictionaryNode,
-        flags: EvaluatorFlags,
-        hasExpectedType: boolean
-    ): TypeResult {
+    function getTypeOfDictionaryInferred(node: DictionaryNode, flags: EvalFlags, hasExpectedType: boolean): TypeResult {
         const fallbackType = hasExpectedType ? AnyType.create() : UnknownType.create();
         let keyType: Type = fallbackType;
         let valueType: Type = fallbackType;
@@ -13568,7 +13524,7 @@ export function createTypeEvaluator(
 
     function getKeyAndValueTypesFromDictionary(
         node: DictionaryNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         keyTypes: TypeResultWithNode[],
         valueTypes: TypeResultWithNode[],
         forceStrictInference: boolean,
@@ -13583,13 +13539,7 @@ export function createTypeEvaluator(
 
         // 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 &
-            ~(
-                EvaluatorFlags.ExpectingTypeExpression |
-                EvaluatorFlags.EvaluateStringLiteralAsType |
-                EvaluatorFlags.ExpectingInstantiableType
-            );
+        const keyFlags = flags & ~(EvalFlags.TypeExpression | EvalFlags.StrLiteralAsType | EvalFlags.InstantiableType);
 
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
@@ -13598,7 +13548,7 @@ export function createTypeEvaluator(
             if (entryNode.nodeType === ParseNodeType.DictionaryKeyEntry) {
                 const keyTypeResult = getTypeOfExpression(
                     entryNode.keyExpression,
-                    keyFlags | EvaluatorFlags.StripLiteralTypeForTuple,
+                    keyFlags | EvalFlags.StripTupleLiterals,
                     makeInferenceContext(
                         expectedKeyType ?? (forceStrictInference ? NeverType.createNever() : undefined)
                     )
@@ -13638,7 +13588,7 @@ export function createTypeEvaluator(
                     entryInferenceContext = makeInferenceContext(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(
                         entryNode.valueExpression,
-                        flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                        flags | EvalFlags.StripTupleLiterals,
                         entryInferenceContext
                     );
                 } else {
@@ -13647,7 +13597,7 @@ export function createTypeEvaluator(
                     entryInferenceContext = makeInferenceContext(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(
                         entryNode.valueExpression,
-                        flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                        flags | EvalFlags.StripTupleLiterals,
                         entryInferenceContext
                     );
                 }
@@ -13710,7 +13660,7 @@ export function createTypeEvaluator(
                 const entryInferenceContext = makeInferenceContext(expectedType);
                 let unexpandedTypeResult = getTypeOfExpression(
                     entryNode.expandExpression,
-                    flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                    flags | EvalFlags.StripTupleLiterals,
                     entryInferenceContext
                 );
 
@@ -13805,7 +13755,7 @@ export function createTypeEvaluator(
             } else if (entryNode.nodeType === ParseNodeType.Comprehension) {
                 const dictEntryTypeResult = getElementTypeFromComprehension(
                     entryNode,
-                    flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                    flags | EvalFlags.StripTupleLiterals,
                     expectedValueType,
                     expectedKeyType
                 );
@@ -13844,11 +13794,11 @@ export function createTypeEvaluator(
 
     function getTypeOfListOrSet(
         node: ListNode | SetNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext | undefined
     ): TypeResult {
         if (
-            (flags & EvaluatorFlags.ExpectingTypeExpression) !== 0 &&
+            (flags & EvalFlags.TypeExpression) !== 0 &&
             node.nodeType === ParseNodeType.List &&
             node.parent?.nodeType !== ParseNodeType.Argument
         ) {
@@ -13857,11 +13807,7 @@ export function createTypeEvaluator(
             addDiagnostic(DiagnosticRule.reportInvalidTypeForm, LocMessage.listInAnnotation() + diag.getString(), node);
         }
 
-        flags &= ~(
-            EvaluatorFlags.ExpectingTypeExpression |
-            EvaluatorFlags.EvaluateStringLiteralAsType |
-            EvaluatorFlags.ExpectingInstantiableType
-        );
+        flags &= ~(EvalFlags.TypeExpression | EvalFlags.StrLiteralAsType | EvalFlags.InstantiableType);
 
         // If the expected type is a union, recursively call for each of the subtypes
         // to find one that matches.
@@ -13920,7 +13866,7 @@ export function createTypeEvaluator(
     // Returns undefined if that type cannot be honored.
     function getTypeOfListOrSetWithContext(
         node: ListNode | SetNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext: InferenceContext
     ): TypeResult | undefined {
         const builtInClassName = node.nodeType === ParseNodeType.List ? 'list' : 'set';
@@ -13947,13 +13893,13 @@ export function createTypeEvaluator(
             if (entry.nodeType === ParseNodeType.Comprehension) {
                 entryTypeResult = getElementTypeFromComprehension(
                     entry,
-                    flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                    flags | EvalFlags.StripTupleLiterals,
                     expectedEntryType
                 );
             } else {
                 entryTypeResult = getTypeOfExpression(
                     entry,
-                    flags | EvaluatorFlags.StripLiteralTypeForTuple,
+                    flags | EvalFlags.StripTupleLiterals,
                     makeInferenceContext(expectedEntryType)
                 );
             }
@@ -14050,7 +13996,7 @@ export function createTypeEvaluator(
     // Attempts to infer the type of a list or set statement with no "expected type".
     function getTypeOfListOrSetInferred(
         node: ListNode | SetNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         hasExpectedType: boolean
     ): TypeResult {
         const builtInClassName = node.nodeType === ParseNodeType.List ? 'list' : 'set';
@@ -14064,12 +14010,9 @@ export function createTypeEvaluator(
             let entryTypeResult: TypeResult;
 
             if (entry.nodeType === ParseNodeType.Comprehension && !entry.isGenerator) {
-                entryTypeResult = getElementTypeFromComprehension(
-                    entry,
-                    flags | EvaluatorFlags.StripLiteralTypeForTuple
-                );
+                entryTypeResult = getElementTypeFromComprehension(entry, flags | EvalFlags.StripTupleLiterals);
             } else {
-                entryTypeResult = getTypeOfExpression(entry, flags | EvaluatorFlags.StripLiteralTypeForTuple);
+                entryTypeResult = getTypeOfExpression(entry, flags | EvalFlags.StripTupleLiterals);
             }
 
             if (entryTypeResult.isIncomplete) {
@@ -14338,7 +14281,7 @@ export function createTypeEvaluator(
         return invalidateTypeCacheIfCanceled(() => {
             // Pre-cache the incomplete function type in case the evaluation of the
             // lambda depends on itself.
-            writeTypeCache(node, { type: functionType, isIncomplete: true }, EvaluatorFlags.None);
+            writeTypeCache(node, { type: functionType, isIncomplete: true }, 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
@@ -14382,13 +14325,13 @@ export function createTypeEvaluator(
                     writeTypeCache(
                         param.name,
                         { type: transformVariadicParamType(node, param.category, paramType ?? UnknownType.create()) },
-                        EvaluatorFlags.None
+                        EvalFlags.None
                     );
                 }
 
                 if (param.defaultValue) {
                     // Evaluate the default value if it's present.
-                    getTypeOfExpression(param.defaultValue, EvaluatorFlags.ConvertEllipsisToAny);
+                    getTypeOfExpression(param.defaultValue, EvalFlags.ConvertEllipsisToAny);
                 }
 
                 // Determine whether we need to insert an implied position-only parameter.
@@ -14502,7 +14445,7 @@ export function createTypeEvaluator(
 
     function getTypeOfComprehension(
         node: ComprehensionNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         inferenceContext?: InferenceContext
     ): TypeResult {
         let isIncomplete = false;
@@ -14528,7 +14471,7 @@ export function createTypeEvaluator(
         const expectedEntryType = getExpectedEntryTypeForIterable(node, builtInIteratorType, inferenceContext);
         const elementTypeResult = getElementTypeFromComprehension(
             node,
-            flags | EvaluatorFlags.StripLiteralTypeForTuple,
+            flags | EvalFlags.StripTupleLiterals,
             expectedEntryType
         );
 
@@ -14635,7 +14578,7 @@ export function createTypeEvaluator(
     // Returns the type of one entry returned by the comprehension.
     function getElementTypeFromComprehension(
         node: ComprehensionNode,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         expectedValueOrElementType?: Type,
         expectedKeyType?: Type
     ): TypeResult {
@@ -14926,13 +14869,13 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
         if (!typeArgs) {
             // 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 & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+            if ((flags & EvalFlags.TypeExpression) !== 0) {
                 addError(LocMessage.optionalExtraArgs(), errorNode);
                 return UnknownType.create();
             }
@@ -14987,7 +14930,7 @@ export function createTypeEvaluator(
     }
 
     // Creates a type that represents a Literal.
-    function createLiteralType(classType: ClassType, node: IndexNode, flags: EvaluatorFlags): Type {
+    function createLiteralType(classType: ClassType, node: IndexNode, flags: EvalFlags): Type {
         if (node.items.length === 0) {
             addError(LocMessage.literalEmptyArgs(), node.baseExpression);
             return UnknownType.create();
@@ -15057,8 +15000,7 @@ export function createTypeEvaluator(
             if (!type) {
                 const exprType = getTypeOfExpression(
                     itemExpr,
-                    (flags & EvaluatorFlags.AllowForwardReferences) |
-                        EvaluatorFlags.SkipConvertSpecialFormToRuntimeObject
+                    (flags & EvalFlags.ForwardRefs) | EvalFlags.NoConvertSpecialForm
                 );
 
                 // Is this an enum type?
@@ -15108,9 +15050,9 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
-        if (flags & EvaluatorFlags.DisallowClassVar) {
+        if (flags & EvalFlags.NoClassVar) {
             addError(LocMessage.classVarNotAllowed(), errorNode);
             return AnyType.create();
         }
@@ -15148,13 +15090,13 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
         // 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) {
-            if ((flags & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+            if ((flags & EvalFlags.TypeExpression) !== 0) {
                 addError(LocMessage.typeGuardArgCount(), errorNode);
             }
 
@@ -15175,7 +15117,7 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ) {
         // Self doesn't support any type arguments.
         if (typeArgs) {
@@ -15199,7 +15141,7 @@ export function createTypeEvaluator(
 
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
-            if ((flags & (EvaluatorFlags.ExpectingTypeExpression | EvaluatorFlags.ExpectingInstantiableType)) !== 0) {
+            if ((flags & (EvalFlags.TypeExpression | EvalFlags.InstantiableType)) !== 0) {
                 addDiagnostic(DiagnosticRule.reportGeneralTypeIssues, LocMessage.selfTypeContext(), errorNode);
             }
 
@@ -15256,12 +15198,12 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): TypeResult {
         // 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 & EvaluatorFlags.ExpectingTypeExpression) === 0) {
+        if (!typeArgs && (flags & EvalFlags.TypeExpression) === 0) {
             return { type: classType };
         }
 
@@ -15296,7 +15238,7 @@ export function createTypeEvaluator(
             }
         }
 
-        if ((flags & EvaluatorFlags.AllowRequired) !== 0) {
+        if ((flags & EvalFlags.AllowRequired) !== 0) {
             isUsageLegal = true;
         }
 
@@ -15340,12 +15282,12 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
         // 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 & EvaluatorFlags.ExpectingTypeExpression) === 0) {
+        if (!typeArgs && (flags & EvalFlags.TypeExpression) === 0) {
             return classType;
         }
 
@@ -15359,7 +15301,7 @@ export function createTypeEvaluator(
             typeArgType = typeArgType.subtypes[0];
         }
 
-        if ((flags & EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple) !== 0) {
+        if ((flags & EvalFlags.AllowUnpackedTuple) !== 0) {
             if (isInstantiableClass(typeArgType) && !typeArgType.includeSubclasses && isTupleClass(typeArgType)) {
                 return ClassType.cloneForUnpacked(typeArgType);
             }
@@ -15372,7 +15314,7 @@ export function createTypeEvaluator(
             return UnknownType.create();
         }
 
-        if ((flags & EvaluatorFlags.AllowUnpackedTypedDict) !== 0) {
+        if ((flags & EvalFlags.AllowUnpackedTypedDict) !== 0) {
             if (isInstantiableClass(typeArgType) && ClassType.isTypedDictClass(typeArgType)) {
                 return ClassType.cloneForUnpacked(typeArgType);
             }
@@ -15390,9 +15332,9 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
-        if (flags & EvaluatorFlags.DisallowFinal) {
+        if (flags & EvalFlags.NoFinal) {
             addError(LocMessage.finalContext(), errorNode);
             return classType;
         }
@@ -15412,9 +15354,9 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
-        if ((flags & EvaluatorFlags.AllowConcatenate) === 0) {
+        if ((flags & EvalFlags.AllowConcatenate) === 0) {
             addError(LocMessage.concatenateContext(), errorNode);
             return AnyType.create();
         }
@@ -15446,10 +15388,9 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ExpressionNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): TypeResult {
-        const typeExprFlags =
-            EvaluatorFlags.ExpectingTypeExpression | EvaluatorFlags.SkipConvertSpecialFormToRuntimeObject;
+        const typeExprFlags = EvalFlags.TypeExpression | EvalFlags.NoConvertSpecialForm;
         if ((flags & typeExprFlags) === 0) {
             return { type: classType };
         }
@@ -15666,7 +15607,7 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         const types: Type[] = [];
@@ -15676,7 +15617,7 @@ export function createTypeEvaluator(
             // 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 & EvaluatorFlags.ExpectingTypeExpression) !== 0) {
+            if ((flags & EvalFlags.TypeExpression) !== 0) {
                 addError(LocMessage.unionTypeArgCount(), errorNode);
                 return NeverType.createNever();
             }
@@ -15757,13 +15698,13 @@ export function createTypeEvaluator(
         classType: ClassType,
         errorNode: ParseNode,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags
+        flags: EvalFlags
     ): Type {
         if (!typeArgs) {
             // 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 & (EvaluatorFlags.ExpectingTypeExpression | EvaluatorFlags.DisallowNakedGeneric)) !== 0) {
+            if ((flags & (EvalFlags.TypeExpression | EvalFlags.NoNakedGeneric)) !== 0) {
                 addError(LocMessage.genericTypeArgMissing(), errorNode);
             }
 
@@ -16050,7 +15991,7 @@ export function createTypeEvaluator(
         const aliasMapEntry = specialTypes.get(assignedName);
 
         if (aliasMapEntry) {
-            const cachedType = readTypeCache(node, EvaluatorFlags.None);
+            const cachedType = readTypeCache(node, EvalFlags.None);
             if (cachedType) {
                 assert(isInstantiableClass(cachedType));
                 return cachedType as ClassType;
@@ -16065,7 +16006,7 @@ export function createTypeEvaluator(
                 computeMroLinearization(specialType);
             }
 
-            writeTypeCache(node, { type: specialType }, EvaluatorFlags.None);
+            writeTypeCache(node, { type: specialType }, EvalFlags.None);
             return specialType;
         }
 
@@ -16123,10 +16064,10 @@ export function createTypeEvaluator(
             return;
         }
 
-        let flags: EvaluatorFlags = EvaluatorFlags.None;
+        let flags: EvalFlags = EvalFlags.None;
         if (fileInfo.isStubFile) {
             // An assignment of ellipsis means "Any" within a type stub file.
-            flags |= EvaluatorFlags.ConvertEllipsisToAny;
+            flags |= EvalFlags.ConvertEllipsisToAny;
         }
 
         if (
@@ -16136,7 +16077,7 @@ export function createTypeEvaluator(
             // 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 |= EvaluatorFlags.DoNotSpecialize;
+            flags |= EvalFlags.NoSpecialize;
         }
 
         // Is this type already cached?
@@ -16150,7 +16091,7 @@ export function createTypeEvaluator(
             if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
                 rightHandType = handleTypingStubAssignment(node);
                 if (rightHandType) {
-                    writeTypeCache(node.rightExpression, { type: rightHandType }, EvaluatorFlags.None);
+                    writeTypeCache(node.rightExpression, { type: rightHandType }, EvalFlags.None);
                 }
             }
         }
@@ -16165,12 +16106,12 @@ export function createTypeEvaluator(
 
             if (isDeclaredTypeAlias(node.leftExpression)) {
                 flags =
-                    EvaluatorFlags.ExpectingInstantiableType |
-                    EvaluatorFlags.ExpectingTypeExpression |
-                    EvaluatorFlags.EvaluateStringLiteralAsType |
-                    EvaluatorFlags.DisallowParamSpec |
-                    EvaluatorFlags.DisallowTypeVarTuple |
-                    EvaluatorFlags.DisallowClassVar;
+                    EvalFlags.InstantiableType |
+                    EvalFlags.TypeExpression |
+                    EvalFlags.StrLiteralAsType |
+                    EvalFlags.NoParamSpec |
+                    EvalFlags.NoTypeVarTuple |
+                    EvalFlags.NoClassVar;
 
                 typeAliasNameNode = (node.leftExpression as TypeAnnotationNode).valueExpression as NameNode;
 
@@ -16195,7 +16136,7 @@ export function createTypeEvaluator(
                         if (isPossibleTypeAliasDeclaration(decls[0])) {
                             typeAliasNameNode = node.leftExpression;
                             isSpeculativeTypeAlias = true;
-                            flags |= EvaluatorFlags.SkipConvertSpecialFormToRuntimeObject;
+                            flags |= EvalFlags.NoConvertSpecialForm;
                         } else if (isPossibleTypeDictFactoryCall(decls[0])) {
                             // Handle calls to TypedDict factory functions like type
                             // aliases to support recursive field type definitions.
@@ -16291,7 +16232,7 @@ export function createTypeEvaluator(
             expectedTypeDiagAddendum
         );
 
-        writeTypeCache(node, { type: rightHandType, isIncomplete }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: rightHandType, isIncomplete }, EvalFlags.None);
     }
 
     // Synthesize a TypeVar that acts as a placeholder for a type alias. This allows
@@ -16337,7 +16278,7 @@ export function createTypeEvaluator(
         typeParamNodes: TypeParameterNode[] | undefined,
         getTypeParamCallback: () => TypeVarType[] | undefined
     ) {
-        const cachedType = readTypeCache(nameNode, EvaluatorFlags.None);
+        const cachedType = readTypeCache(nameNode, EvalFlags.None);
         if (cachedType) {
             return cachedType;
         }
@@ -16397,7 +16338,7 @@ export function createTypeEvaluator(
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
 
-        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, EvaluatorFlags.None);
+        writeTypeCache(nameNode, { type: aliasType, isIncomplete }, EvalFlags.None);
 
         return aliasType;
     }
@@ -16409,7 +16350,7 @@ export function createTypeEvaluator(
 
         const destTypeResult = getTypeOfAugmentedAssignment(evaluatorInterface, node, /* inferenceContext */ undefined);
 
-        writeTypeCache(node, destTypeResult, EvaluatorFlags.None);
+        writeTypeCache(node, destTypeResult, EvalFlags.None);
     }
 
     function getPseudoGenericTypeVarName(paramName: string) {
@@ -16420,7 +16361,7 @@ export function createTypeEvaluator(
         initializePrefetchedTypes(node);
 
         // Is this type already cached?
-        const cachedClassType = readTypeCache(node.name, EvaluatorFlags.None);
+        const cachedClassType = readTypeCache(node.name, EvalFlags.None);
 
         if (cachedClassType) {
             if (!isInstantiableClass(cachedClassType)) {
@@ -16430,7 +16371,7 @@ export function createTypeEvaluator(
             }
             return {
                 classType: cachedClassType,
-                decoratedType: readTypeCache(node, EvaluatorFlags.None) || UnknownType.create(),
+                decoratedType: readTypeCache(node, EvalFlags.None) || UnknownType.create(),
             };
         }
 
@@ -16522,14 +16463,14 @@ export function createTypeEvaluator(
             const initSubclassArgs: FunctionArgument[] = [];
             let metaclassNode: ExpressionNode | undefined;
             let exprFlags =
-                EvaluatorFlags.ExpectingInstantiableType |
-                EvaluatorFlags.AllowGenericClassType |
-                EvaluatorFlags.DisallowNakedGeneric |
-                EvaluatorFlags.DisallowTypeVarsWithScopeId |
-                EvaluatorFlags.AssociateTypeVarsWithCurrentScope |
-                EvaluatorFlags.EnforceTypeVarVarianceConsistency;
+                EvalFlags.InstantiableType |
+                EvalFlags.AllowGeneric |
+                EvalFlags.NoNakedGeneric |
+                EvalFlags.NoTypeVarWithScopeId |
+                EvalFlags.TypeVarGetsCurScope |
+                EvalFlags.EnforceVarianceConsistency;
             if (fileInfo.isStubFile) {
-                exprFlags |= EvaluatorFlags.AllowForwardReferences;
+                exprFlags |= EvalFlags.ForwardRefs;
             }
 
             node.arguments.forEach((arg) => {
@@ -17191,10 +17132,10 @@ export function createTypeEvaluator(
             };
 
             // Update the undecorated class type.
-            writeTypeCache(node.name, { type: classType }, EvaluatorFlags.None);
+            writeTypeCache(node.name, { type: classType }, EvalFlags.None);
 
             // Update the decorated class type.
-            writeTypeCache(node, { type: decoratedType }, EvaluatorFlags.None);
+            writeTypeCache(node, { type: decoratedType }, EvalFlags.None);
 
             return { classType, decoratedType };
         });
@@ -17360,7 +17301,7 @@ export function createTypeEvaluator(
                 return;
             }
 
-            writeTypeCache(param.name, { type: typeOfParam }, EvaluatorFlags.None);
+            writeTypeCache(param.name, { type: typeOfParam }, EvalFlags.None);
             paramTypes.push(typeOfParam);
         });
 
@@ -17488,7 +17429,7 @@ export function createTypeEvaluator(
         deferredClassCompletions.forEach((e) => {
             if (ClassType.isSameGenericClass(e.dependsUpon, type)) {
                 e.classesToComplete.forEach((classNode) => {
-                    const classType = readTypeCache(classNode.name, EvaluatorFlags.None);
+                    const classType = readTypeCache(classNode.name, EvalFlags.None);
                     if (classType) {
                         completeClassTypeDeferred(classType as ClassType, classNode.name);
                     }
@@ -17693,7 +17634,7 @@ export function createTypeEvaluator(
         initializePrefetchedTypes(node);
 
         // Is this predecorated function type cached?
-        let functionType = readTypeCache(node.name, EvaluatorFlags.None);
+        let functionType = readTypeCache(node.name, EvalFlags.None);
 
         if (functionType) {
             if (!isFunction(functionType)) {
@@ -17710,7 +17651,7 @@ export function createTypeEvaluator(
         }
 
         // Is the decorated function type cached?
-        let decoratedType = readTypeCache(node, EvaluatorFlags.None);
+        let decoratedType = readTypeCache(node, EvalFlags.None);
         if (decoratedType) {
             return { functionType, decoratedType };
         }
@@ -17771,7 +17712,7 @@ export function createTypeEvaluator(
             decoratedType = addOverloadsToFunctionType(evaluatorInterface, node, decoratedType);
         }
 
-        writeTypeCache(node, { type: decoratedType }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: decoratedType }, EvalFlags.None);
 
         return { functionType, decoratedType };
     }
@@ -17782,7 +17723,7 @@ export function createTypeEvaluator(
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
 
         // Is this type already cached?
-        const cachedFunctionType = readTypeCache(node.name, EvaluatorFlags.None);
+        const cachedFunctionType = readTypeCache(node.name, EvalFlags.None);
 
         if (cachedFunctionType && isFunction(cachedFunctionType)) {
             return cachedFunctionType;
@@ -18001,7 +17942,7 @@ export function createTypeEvaluator(
 
                     defaultValueType = getTypeOfExpression(
                         param.defaultValue,
-                        treatEllipsisAsAny ? EvaluatorFlags.ConvertEllipsisToAny : EvaluatorFlags.None,
+                        treatEllipsisAsAny ? EvalFlags.ConvertEllipsisToAny : EvalFlags.None,
                         makeInferenceContext(annotatedType)
                     ).type;
                 }
@@ -18132,7 +18073,7 @@ export function createTypeEvaluator(
                     if (isUnknown(paramType)) {
                         functionType.details.flags |= FunctionTypeFlags.UnannotatedParams;
                     }
-                    writeTypeCache(paramNameNode, { type: paramType }, EvaluatorFlags.None);
+                    writeTypeCache(paramNameNode, { type: paramType }, EvalFlags.None);
                 }
             });
 
@@ -18236,7 +18177,7 @@ export function createTypeEvaluator(
             // is fully evaluated.
             functionType.details.flags &= ~FunctionTypeFlags.PartiallyEvaluated;
 
-            writeTypeCache(node.name, { type: functionType }, EvaluatorFlags.None);
+            writeTypeCache(node.name, { type: functionType }, EvalFlags.None);
 
             return functionType;
         });
@@ -18359,7 +18300,7 @@ export function createTypeEvaluator(
     }
 
     function inferParameterTypeFromDefaultValue(paramValueExpr: ExpressionNode) {
-        const defaultValueType = getTypeOfExpression(paramValueExpr, EvaluatorFlags.ConvertEllipsisToAny).type;
+        const defaultValueType = getTypeOfExpression(paramValueExpr, EvalFlags.ConvertEllipsisToAny).type;
 
         let inferredParamType: Type | undefined;
 
@@ -18551,7 +18492,7 @@ export function createTypeEvaluator(
         }
 
         // Is this type already cached?
-        let inferredReturnType = readTypeCache(node.suite, EvaluatorFlags.None);
+        let inferredReturnType = readTypeCache(node.suite, EvalFlags.None);
         let isIncomplete = false;
 
         if (inferredReturnType) {
@@ -18734,7 +18675,7 @@ export function createTypeEvaluator(
                     }
                 }
 
-                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, EvaluatorFlags.None);
+                writeTypeCache(node.suite, { type: inferredReturnType, isIncomplete }, EvalFlags.None);
             } finally {
                 functionRecursionMap.delete(node.id);
             }
@@ -18796,11 +18737,7 @@ export function createTypeEvaluator(
             node.targetExpression
         );
 
-        writeTypeCache(
-            node,
-            { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete },
-            EvaluatorFlags.None
-        );
+        writeTypeCache(node, { type: iteratedType, isIncomplete: !!iteratorTypeResult.isIncomplete }, EvalFlags.None);
     }
 
     function evaluateTypesForExceptStatement(node: ExceptNode): void {
@@ -18868,7 +18805,7 @@ export function createTypeEvaluator(
             assignTypeToExpression(node.name, { type: targetType }, node.name);
         }
 
-        writeTypeCache(node, { type: targetType }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: targetType }, EvalFlags.None);
     }
 
     function evaluateTypesForWithStatement(node: WithItemNode): void {
@@ -18978,7 +18915,7 @@ export function createTypeEvaluator(
             );
         }
 
-        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: scopedType, isIncomplete: !!exprTypeResult.isIncomplete }, EvalFlags.None);
     }
 
     function evaluateTypesForImportAs(node: ImportAsNode): void {
@@ -19006,7 +18943,7 @@ export function createTypeEvaluator(
 
         // 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, EvaluatorFlags.None) as ModuleType;
+        const cachedModuleType = readTypeCache(node, EvalFlags.None) as ModuleType;
         if (cachedModuleType && isModule(cachedModuleType) && symbolType) {
             if (isTypeSame(symbolType, cachedModuleType)) {
                 symbolType = cachedModuleType;
@@ -19015,7 +18952,7 @@ export function createTypeEvaluator(
 
         assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
 
-        writeTypeCache(node, { type: symbolType }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: symbolType }, EvalFlags.None);
     }
 
     function evaluateTypesForImportFromAs(node: ImportFromAsNode): void {
@@ -19097,7 +19034,7 @@ export function createTypeEvaluator(
         }
 
         assignTypeToNameNode(aliasNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
-        writeTypeCache(node, { type: symbolType }, EvaluatorFlags.None);
+        writeTypeCache(node, { type: symbolType }, EvalFlags.None);
     }
 
     function evaluateTypesForMatchStatement(node: MatchNode): void {
@@ -19120,11 +19057,7 @@ export function createTypeEvaluator(
             }
         }
 
-        writeTypeCache(
-            node,
-            { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete },
-            EvaluatorFlags.None
-        );
+        writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, EvalFlags.None);
     }
 
     function evaluateTypesForCaseStatement(node: CaseNode): void {
@@ -19173,7 +19106,7 @@ export function createTypeEvaluator(
         writeTypeCache(
             node,
             { type: narrowedSubjectType, isIncomplete: !!subjectTypeResult.isIncomplete },
-            EvaluatorFlags.None
+            EvalFlags.None
         );
     }
 
@@ -19184,7 +19117,7 @@ export function createTypeEvaluator(
 
         if (node.isWildcardImport) {
             // Write back a dummy type so we don't evaluate this node again.
-            writeTypeCache(node, { type: AnyType.create() }, EvaluatorFlags.None);
+            writeTypeCache(node, { type: AnyType.create() }, EvalFlags.None);
 
             const flowNode = AnalyzerNodeInfo.getFlowNode(node);
             if (flowNode && (flowNode.flags & FlowFlags.WildcardImport) !== 0) {
@@ -19233,7 +19166,7 @@ export function createTypeEvaluator(
 
             // 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, EvaluatorFlags.None) as ModuleType;
+            const cachedModuleType = readTypeCache(node, EvalFlags.None) as ModuleType;
             if (cachedModuleType && isModule(cachedModuleType) && symbolType) {
                 if (isTypeSame(symbolType, cachedModuleType)) {
                     symbolType = cachedModuleType;
@@ -19242,7 +19175,7 @@ export function createTypeEvaluator(
 
             assignTypeToNameNode(symbolNameNode, { type: symbolType }, /* ignoreEmptyContainers */ false);
 
-            writeTypeCache(node, { type: symbolType }, EvaluatorFlags.None);
+            writeTypeCache(node, { type: symbolType }, EvalFlags.None);
         }
     }
 
@@ -19259,7 +19192,7 @@ export function createTypeEvaluator(
                 allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.valueExpression),
             });
 
-            writeTypeCache(node.valueExpression, { type: annotationType }, EvaluatorFlags.None);
+            writeTypeCache(node.valueExpression, { type: annotationType }, EvalFlags.None);
         }
     }
 
@@ -19381,7 +19314,7 @@ export function createTypeEvaluator(
             if (node.parent.nodeType === ParseNodeType.Global || node.parent.nodeType === ParseNodeType.Nonlocal) {
                 // For global and nonlocal statements, allow forward references so
                 // we don't use code flow during symbol lookups.
-                getTypeOfExpression(node, EvaluatorFlags.AllowForwardReferences);
+                getTypeOfExpression(node, EvalFlags.ForwardRefs);
                 return;
             }
 
@@ -19454,7 +19387,7 @@ export function createTypeEvaluator(
         // Scan up the parse tree until we find a node that doesn't
         // require any context to be evaluated.
         let nodeToEvaluate: ExpressionNode = node;
-        let flags = EvaluatorFlags.None;
+        let flags = EvalFlags.None;
 
         while (true) {
             // If we're within an argument node in a call or index expression, skip
@@ -19521,13 +19454,13 @@ export function createTypeEvaluator(
                         continue;
                     }
 
-                    flags = EvaluatorFlags.CallBaseDefaults;
+                    flags = EvalFlags.CallBaseDefaults;
                     break;
                 }
             } else if (parent.nodeType === ParseNodeType.Index) {
                 // The base expression of an index expression is not contextual.
                 if (nodeToEvaluate === parent.baseExpression) {
-                    flags = EvaluatorFlags.IndexBaseDefaults;
+                    flags = EvalFlags.IndexBaseDefaults;
                 }
             }
 
@@ -19639,7 +19572,7 @@ export function createTypeEvaluator(
                         : undefined;
                     getTypeOfExpression(
                         parent.returnExpression,
-                        EvaluatorFlags.None,
+                        EvalFlags.None,
                         makeInferenceContext(declaredReturnType)
                     );
                     return;
@@ -19701,7 +19634,7 @@ export function createTypeEvaluator(
                 adjustParameterAnnotatedType(param, annotatedType)
             );
 
-            writeTypeCache(node.name, { type: adjType }, EvaluatorFlags.None);
+            writeTypeCache(node.name, { type: adjType }, EvalFlags.None);
             return;
         }
 
@@ -19719,7 +19652,7 @@ export function createTypeEvaluator(
             );
 
             if (paramType) {
-                writeTypeCache(node.name, { type: paramType }, EvaluatorFlags.None);
+                writeTypeCache(node.name, { type: paramType }, EvalFlags.None);
                 return;
             }
         }
@@ -19737,7 +19670,7 @@ export function createTypeEvaluator(
         writeTypeCache(
             node.name,
             { type: transformVariadicParamType(node, node.category, inferredParamType ?? UnknownType.create()) },
-            EvaluatorFlags.None
+            EvalFlags.None
         );
     }
 
@@ -19985,7 +19918,7 @@ export function createTypeEvaluator(
     function createSpecializedClassType(
         classType: ClassType,
         typeArgs: TypeResultWithNode[] | undefined,
-        flags: EvaluatorFlags,
+        flags: EvalFlags,
         errorNode: ExpressionNode
     ): TypeResult {
         // Handle the special-case classes that are not defined
@@ -20034,11 +19967,7 @@ export function createTypeEvaluator(
                 }
 
                 case 'Protocol': {
-                    if (
-                        (flags &
-                            (EvaluatorFlags.DisallowNonTypeSpecialForms | EvaluatorFlags.ExpectingTypeExpression)) !==
-                        0
-                    ) {
+                    if ((flags & (EvalFlags.NoNonTypeSpecialForms | EvalFlags.TypeExpression)) !== 0) {
                         addError(LocMessage.protocolNotAllowed(), errorNode);
                     }
 
@@ -20059,22 +19988,14 @@ export function createTypeEvaluator(
                 }
 
                 case 'TypedDict': {
-                    if (
-                        (flags &
-                            (EvaluatorFlags.DisallowNonTypeSpecialForms | EvaluatorFlags.ExpectingTypeExpression)) !==
-                        0
-                    ) {
+                    if ((flags & (EvalFlags.NoNonTypeSpecialForms | EvalFlags.TypeExpression)) !== 0) {
                         addError(LocMessage.typedDictNotAllowed(), errorNode);
                     }
                     break;
                 }
 
                 case 'Literal': {
-                    if (
-                        (flags &
-                            (EvaluatorFlags.DisallowNonTypeSpecialForms | EvaluatorFlags.ExpectingTypeExpression)) !==
-                        0
-                    ) {
+                    if ((flags & (EvalFlags.NoNonTypeSpecialForms | EvalFlags.TypeExpression)) !== 0) {
                         addError(LocMessage.literalNotAllowed(), errorNode);
                     }
                     break;
@@ -20145,7 +20066,7 @@ export function createTypeEvaluator(
             fileInfo.isStubFile ||
             fileInfo.executionEnvironment.pythonVersion.isGreaterOrEqualTo(pythonVersion3_9) ||
             isAnnotationEvaluationPostponed(AnalyzerNodeInfo.getFileInfo(errorNode)) ||
-            (flags & EvaluatorFlags.AllowForwardReferences) !== 0
+            (flags & EvalFlags.ForwardRefs) !== 0
         ) {
             // Handle "type" specially, since it needs to act like "Type"
             // in Python 3.9 and newer.
@@ -20405,7 +20326,7 @@ export function createTypeEvaluator(
                 let adjustedTypeArgType = applyTypeArgToTypeVar(typeParameters[index], typeArgType, diag);
 
                 // Determine if the variance must match.
-                if (adjustedTypeArgType && (flags & EvaluatorFlags.EnforceTypeVarVarianceConsistency) !== 0) {
+                if (adjustedTypeArgType && (flags & EvalFlags.EnforceVarianceConsistency) !== 0) {
                     const destType = typeParameters[index];
                     const declaredVariance = destType.details.declaredVariance;
 
@@ -20504,46 +20425,43 @@ export function createTypeEvaluator(
     }
 
     function getTypeOfExpressionExpectingType(node: ExpressionNode, options?: ExpectedTypeOptions): TypeResult {
-        let flags =
-            EvaluatorFlags.ExpectingInstantiableType |
-            EvaluatorFlags.EvaluateStringLiteralAsType |
-            EvaluatorFlags.DisallowClassVar;
+        let flags = EvalFlags.InstantiableType | EvalFlags.StrLiteralAsType | EvalFlags.NoClassVar;
 
         if (options?.allowTypeVarsWithoutScopeId) {
-            flags |= EvaluatorFlags.AllowTypeVarsWithoutScopeId;
+            flags |= EvalFlags.AllowTypeVarWithoutScopeId;
         }
 
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile || options?.allowForwardReference) {
-            flags |= EvaluatorFlags.AllowForwardReferences;
+            flags |= EvalFlags.ForwardRefs;
         } else {
-            flags |= EvaluatorFlags.InterpreterParsesStringLiteral;
+            flags |= EvalFlags.ParsesStringLiteral;
         }
 
         if (!options || !options.allowFinal) {
-            flags |= EvaluatorFlags.DisallowFinal;
+            flags |= EvalFlags.NoFinal;
         }
 
         if (options?.allowRequired) {
-            flags |= EvaluatorFlags.AllowRequired | EvaluatorFlags.ExpectingTypeExpression;
+            flags |= EvalFlags.AllowRequired | EvalFlags.TypeExpression;
         }
 
         if (options?.allowUnpackedTuple) {
-            flags |= EvaluatorFlags.AllowUnpackedTupleOrTypeVarTuple;
+            flags |= EvalFlags.AllowUnpackedTuple;
         } else {
-            flags |= EvaluatorFlags.DisallowTypeVarTuple;
+            flags |= EvalFlags.NoTypeVarTuple;
         }
 
         if (!options || !options.allowParamSpec) {
-            flags |= EvaluatorFlags.DisallowParamSpec;
+            flags |= EvalFlags.NoParamSpec;
         }
 
         if (options?.enforceTypeAnnotationRules) {
-            flags |= EvaluatorFlags.ExpectingTypeExpression;
+            flags |= EvalFlags.TypeExpression;
         }
 
         if (options?.disallowProtocolAndTypedDict) {
-            flags |= EvaluatorFlags.DisallowNonTypeSpecialForms;
+            flags |= EvalFlags.NoNonTypeSpecialForms;
         }
 
         return getTypeOfExpression(node, flags);
@@ -21197,7 +21115,7 @@ export function createTypeEvaluator(
 
     function getTypeOfTypeParameter(node: TypeParameterNode): TypeVarType {
         // Is this type already cached?
-        const cachedTypeVarType = readTypeCache(node.name, EvaluatorFlags.None) as FunctionType;
+        const cachedTypeVarType = readTypeCache(node.name, EvalFlags.None) as FunctionType;
         if (cachedTypeVarType && isTypeVar(cachedTypeVarType)) {
             return cachedTypeVarType;
         }
@@ -21449,7 +21367,7 @@ export function createTypeEvaluator(
                 if (resolvedDecl.inferredTypeSource?.nodeType === ParseNodeType.Call) {
                     const baseTypeResult = getTypeOfExpression(
                         resolvedDecl.inferredTypeSource.leftExpression,
-                        EvaluatorFlags.CallBaseDefaults
+                        EvalFlags.CallBaseDefaults
                     );
                     const callType = baseTypeResult.type;
 
@@ -22280,7 +22198,7 @@ export function createTypeEvaluator(
                         }
 
                         paramTypes.push(paramType);
-                        writeTypeCache(param.name, { type: paramType }, EvaluatorFlags.None);
+                        writeTypeCache(param.name, { type: paramType }, EvalFlags.None);
                     }
                 });
 
@@ -27160,7 +27078,7 @@ export function createTypeEvaluator(
         ) {
             // See if this is a call to TypedDict. We want to support
             // recursive type references in a TypedDict call.
-            const callType = getTypeOfExpression(callLeftNode, EvaluatorFlags.CallBaseDefaults).type;
+            const callType = getTypeOfExpression(callLeftNode, EvalFlags.CallBaseDefaults).type;
 
             if (isInstantiableClass(callType) && ClassType.isBuiltIn(callType, 'TypedDict')) {
                 return true;
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluatorTypes.ts b/packages/pyright-internal/src/analyzer/typeEvaluatorTypes.ts
index 7ee7baac2..67de08de5 100644
--- a/packages/pyright-internal/src/analyzer/typeEvaluatorTypes.ts
+++ b/packages/pyright-internal/src/analyzer/typeEvaluatorTypes.ts
@@ -56,7 +56,7 @@ import {
 // a list) before the type is considered an "Any".
 export const maxSubtypesForInferredType = 64;
 
-export const enum EvaluatorFlags {
+export const enum EvalFlags {
     None = 0,
 
     // Interpret an ellipsis type annotation to mean "Any".
@@ -65,106 +65,107 @@ export const enum EvaluatorFlags {
     // Normally a generic named type is specialized with "Any"
     // types. This flag indicates that specialization shouldn't take
     // place.
-    DoNotSpecialize = 1 << 1,
+    NoSpecialize = 1 << 1,
 
     // Allow forward references. Don't report unbound errors.
-    AllowForwardReferences = 1 << 2,
+    ForwardRefs = 1 << 2,
 
     // Treat string literal as a type.
-    EvaluateStringLiteralAsType = 1 << 3,
+    StrLiteralAsType = 1 << 3,
 
     // 'Final' is not allowed in this context.
-    DisallowFinal = 1 << 4,
+    NoFinal = 1 << 4,
 
     // A ParamSpec isn't allowed in this context.
-    DisallowParamSpec = 1 << 5,
+    NoParamSpec = 1 << 5,
 
     // A TypeVarTuple isn't allowed in this context.
-    DisallowTypeVarTuple = 1 << 6,
+    NoTypeVarTuple = 1 << 6,
 
     // Expression is expected to be an instantiable type rather
     // than an instance (object)
-    ExpectingInstantiableType = 1 << 7,
+    InstantiableType = 1 << 7,
 
     // A type expression imposes grammatical and semantic limits on an
     // expression. If this flag is set, illegal type expressions are
     // flagged as errors.
-    ExpectingTypeExpression = 1 << 8,
+    TypeExpression = 1 << 8,
 
     // Suppress the reportMissingTypeArgument diagnostic in this context.
     AllowMissingTypeArgs = 1 << 9,
 
     // The Generic class type is allowed in this context. It is
     // normally not allowed if ExpectingType is set.
-    AllowGenericClassType = 1 << 10,
+    AllowGeneric = 1 << 10,
 
     // TypeVars within this expression must not refer to type vars
     // used in an outer scope.
-    DisallowTypeVarsWithScopeId = 1 << 11,
+    NoTypeVarWithScopeId = 1 << 11,
 
     // TypeVars within this expression do not need to refer to type vars
     // used in an outer scope.
-    AllowTypeVarsWithoutScopeId = 1 << 12,
+    AllowTypeVarWithoutScopeId = 1 << 12,
 
     // TypeVars within this expression that are otherwise not
     // associated with an outer scope should be associated with
     // the containing function's scope.
-    AssociateTypeVarsWithCurrentScope = 1 << 13,
+    TypeVarGetsCurScope = 1 << 13,
 
     // When a new class-scoped TypeVar is used within a class
     // declaration, make sure that it is not used to parameterize
     // a base class whose TypeVar variance is inconsistent.
-    EnforceTypeVarVarianceConsistency = 1 << 14,
+    EnforceVarianceConsistency = 1 << 14,
 
     // Used for PEP 526-style variable type annotations
-    VariableTypeAnnotation = 1 << 15,
+    VarTypeAnnotation = 1 << 15,
 
     // 'ClassVar' is not allowed in this context.
-    DisallowClassVar = 1 << 17,
+    NoClassVar = 1 << 17,
 
     // 'Generic' cannot be used without type arguments in this context.
-    DisallowNakedGeneric = 1 << 18,
+    NoNakedGeneric = 1 << 18,
 
     // The node is not parsed by the interpreter because it is within
     // a comment or a string literal.
-    NotParsedByInterpreter = 1 << 19,
+    NotParsed = 1 << 19,
 
     // Required and NotRequired are allowed in this context.
     AllowRequired = 1 << 20,
 
     // Allow Unpack annotation for a tuple or TypeVarTuple.
-    AllowUnpackedTupleOrTypeVarTuple = 1 << 21,
+    AllowUnpackedTuple = 1 << 21,
+
+    // Allow Unpack annotation for TypedDict.
+    AllowUnpackedTypedDict = 1 << 22,
 
     // Even though an expression is enclosed in a string literal,
     // the interpreter (within a source file, not a stub) still
     // parses the expression and generates parse errors.
-    InterpreterParsesStringLiteral = 1 << 22,
-
-    // Allow Unpack annotation for TypedDict.
-    AllowUnpackedTypedDict = 1 << 23,
+    ParsesStringLiteral = 1 << 23,
 
     // Do not convert special forms to their corresponding runtime
     // objects even when expecting a type expression.
-    SkipConvertSpecialFormToRuntimeObject = 1 << 25,
+    NoConvertSpecialForm = 1 << 25,
 
-    // Protocol and TypedDict are not allowed in this context.
-    DisallowNonTypeSpecialForms = 1 << 26,
+    // Certain special forms (Protocol, TypedDict, etc.) are not allowed
+    // in this context.
+    NoNonTypeSpecialForms = 1 << 26,
 
     // Allow use of the Concatenate special form.
     AllowConcatenate = 1 << 27,
 
     // Do not infer literal types within a tuple (used for tuples nested within
     // other container classes).
-    StripLiteralTypeForTuple = 1 << 28,
+    StripTupleLiterals = 1 << 28,
 
     // Defaults used for evaluating the LHS of a call expression.
-    CallBaseDefaults = DoNotSpecialize,
+    CallBaseDefaults = NoSpecialize,
 
     // Defaults used for evaluating the LHS of a member access expression.
-    IndexBaseDefaults = DoNotSpecialize,
+    IndexBaseDefaults = NoSpecialize,
 
     // Defaults used for evaluating the LHS of a member access expression.
-    MemberAccessBaseDefaults = DoNotSpecialize,
+    MemberAccessBaseDefaults = NoSpecialize,
 }
 
 export interface TypeResult<T extends Type = Type> {
@@ -470,7 +471,7 @@ export interface TypeEvaluator {
     getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
     getTypeResultForDecorator: (node: DecoratorNode) => TypeResult | undefined;
     getCachedType: (node: ExpressionNode) => Type | undefined;
-    getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, context?: InferenceContext) => TypeResult;
+    getTypeOfExpression: (node: ExpressionNode, flags?: EvalFlags, context?: InferenceContext) => TypeResult;
     getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
     getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
     getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
@@ -648,7 +649,7 @@ export interface TypeEvaluator {
         flags: AssignTypeFlags,
         recursionCount: number
     ) => boolean;
-    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvaluatorFlags) => Type;
+    reportMissingTypeArguments: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
 
     isFinalVariable: (symbol: Symbol) => boolean;
     isFinalVariableDeclaration: (decl: Declaration) => boolean;
@@ -680,7 +681,7 @@ export interface TypeEvaluator {
     disposeEvaluator: () => void;
     useSpeculativeMode: <T>(speculativeNode: ParseNode | undefined, callback: () => T) => T;
     isSpeculativeModeInUse: (node: ParseNode | undefined) => boolean;
-    setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvaluatorFlags) => void;
+    setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvalFlags) => void;
 
     checkForCancellation: () => void;
     printControlFlowGraph: (
diff --git a/packages/pyright-internal/src/analyzer/typeGuards.ts b/packages/pyright-internal/src/analyzer/typeGuards.ts
index 8a19a3829..da408bbe0 100644
--- a/packages/pyright-internal/src/analyzer/typeGuards.ts
+++ b/packages/pyright-internal/src/analyzer/typeGuards.ts
@@ -30,7 +30,7 @@ import { ScopeType } from './scope';
 import { getScopeForNode } from './scopeUtils';
 import { Symbol, SymbolFlags } from './symbol';
 import { getTypedDictMembersForClass } from './typedDicts';
-import { EvaluatorFlags, TypeEvaluator } from './typeEvaluatorTypes';
+import { EvalFlags, TypeEvaluator } from './typeEvaluatorTypes';
 import {
     ClassType,
     ClassTypeFlags,
@@ -219,7 +219,7 @@ export function getTypeNarrowingCallback(
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                         const callType = evaluator.getTypeOfExpression(
                             testExpression.leftExpression.leftExpression,
-                            EvaluatorFlags.CallBaseDefaults
+                            EvalFlags.CallBaseDefaults
                         ).type;
 
                         if (isInstantiableClass(callType) && ClassType.isBuiltIn(callType, 'type')) {
@@ -512,7 +512,7 @@ export function getTypeNarrowingCallback(
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 const callTypeResult = evaluator.getTypeOfExpression(
                     testExpression.leftExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const callType = callTypeResult.type;
 
@@ -618,7 +618,7 @@ export function getTypeNarrowingCallback(
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 const callTypeResult = evaluator.getTypeOfExpression(
                     testExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const callType = callTypeResult.type;
 
@@ -629,12 +629,12 @@ export function getTypeNarrowingCallback(
                     const isInstanceCheck = callType.details.builtInName === 'isinstance';
                     const arg1TypeResult = evaluator.getTypeOfExpression(
                         arg1Expr,
-                        EvaluatorFlags.AllowMissingTypeArgs |
-                            EvaluatorFlags.EvaluateStringLiteralAsType |
-                            EvaluatorFlags.DisallowParamSpec |
-                            EvaluatorFlags.DisallowTypeVarTuple |
-                            EvaluatorFlags.DisallowFinal |
-                            EvaluatorFlags.DoNotSpecialize
+                        EvalFlags.AllowMissingTypeArgs |
+                            EvalFlags.StrLiteralAsType |
+                            EvalFlags.NoParamSpec |
+                            EvalFlags.NoTypeVarTuple |
+                            EvalFlags.NoFinal |
+                            EvalFlags.NoSpecialize
                     );
                     const arg1Type = arg1TypeResult.type;
 
@@ -676,7 +676,7 @@ export function getTypeNarrowingCallback(
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 const callTypeResult = evaluator.getTypeOfExpression(
                     testExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const callType = callTypeResult.type;
 
@@ -711,7 +711,7 @@ export function getTypeNarrowingCallback(
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
                 const callTypeResult = evaluator.getTypeOfExpression(
                     testExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const callType = callTypeResult.type;
 
@@ -743,7 +743,7 @@ export function getTypeNarrowingCallback(
 
                 const callTypeResult = evaluator.getTypeOfExpression(
                     testExpression.leftExpression,
-                    EvaluatorFlags.CallBaseDefaults
+                    EvalFlags.CallBaseDefaults
                 );
                 const callType = callTypeResult.type;