@zzzen/pyright-internal 1.2.0-dev.20260816 → 1.2.0-dev.20260830

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -5,6 +5,7 @@ import { DiagnosticRule } from '../common/diagnosticRules';
 import { TextRange } from '../common/textRange';
 import { ArgCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParamCategory, ParameterNode, ParseNode, StringNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
+import { AnalyzerNodeInfoReader } from './analyzerNodeInfo';
 import { CodeFlowReferenceExpressionNode, FlowNode } from './codeFlowTypes';
 import { ConstraintTracker } from './constraintTracker';
 import { Declaration } from './declaration';
@@ -308,6 +309,7 @@ export declare const enum AssignTypeFlags {
 export interface TypeEvaluator {
     runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
     runWithCancellationToken<T>(token: CancellationToken, callback: () => Promise<T>): Promise<T>;
+    getAnalyzerNodeInfoReader: () => AnalyzerNodeInfoReader;
     getType: (node: ExpressionNode) => Type | undefined;
     getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
     getTypeResultForDecorator: (node: DecoratorNode) => TypeResult | undefined;

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA2ZH,oEAEC;AA5WD,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,2EAA2E;AAC3E,4EAA4E;AAC5E,yBAAyB;AACZ,QAAA,yBAAyB,GAAG,CAAC,CAAC;AAE3C,IAAkB,SA0IjB;AA1ID,WAAkB,SAAS;IACvB,yCAAQ,CAAA;IAER,uDAAuD;IACvD,yEAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yDAAqB,CAAA;IAErB,yDAAyD;IACzD,uDAAoB,CAAA;IAEpB,kCAAkC;IAClC,iEAAyB,CAAA;IAEzB,0CAA0C;IAC1C,gDAAgB,CAAA;IAEhB,6CAA6C;IAC7C,wDAAoB,CAAA;IAEpB,gDAAgD;IAChD,8DAAuB,CAAA;IAEvB,2DAA2D;IAC3D,4BAA4B;IAC5B,mEAAyB,CAAA;IAEzB,kEAAkE;IAClE,gEAAgE;IAChE,qBAAqB;IACrB,+DAAuB,CAAA;IAEvB,qEAAqE;IACrE,2EAA6B,CAAA;IAE7B,2DAA2D;IAC3D,gDAAgD;IAChD,4DAAsB,CAAA;IAEtB,8DAA8D;IAC9D,0BAA0B;IAC1B,4EAA8B,CAAA;IAE9B,oEAAoE;IACpE,0BAA0B;IAC1B,wFAAoC,CAAA;IAEpC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,0EAA6B,CAAA;IAE7B,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,yFAAoC,CAAA;IAEpC,oDAAoD;IACpD,uEAA2B,CAAA;IAE3B,wDAAwD;IACxD,+DAAuB,CAAA;IAEvB,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uCAAuC;IACvC,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,8EAA6B,CAAA;IAE7B,8DAA8D;IAC9D,iDAAiD;IACjD,gFAA8B,CAAA;IAE9B,oEAAoE;IACpE,mBAAmB;IACnB,kFAA+B,CAAA;IAE/B,6CAA6C;IAC7C,yEAA0B,CAAA;IAE1B,2EAA2E;IAC3E,4BAA4B;IAC5B,6EAA4B,CAAA;IAE5B,sEAAsE;IACtE,+DAA+D;IAC/D,mEAAuB,CAAA;IAEvB,yEAAyE;IACzE,+BAA+B;IAC/B,gEAAqB,CAAA;IAErB,yEAAyE;IACzE,8CAA8C;IAC9C,2FAAkC,CAAA;IAElC,6DAA6D;IAC7D,iEAA+B,CAAA;IAE/B,sEAAsE;IACtE,mEAAgC,CAAA;IAEhC,sEAAsE;IACtE,iFAAuC,CAAA;IAEvC,sEAAsE;IACtE,wBAAwB;IACxB,mFAMiB,CAAA;AACrB,CAAC,EA1IiB,SAAS,yBAAT,SAAS,QA0I1B;AAuND,SAAgB,4BAA4B,CAAI,IAAO,EAAE,UAAwB;IAC7E,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC5D,CAAC;AAwFD,IAAY,YAiBX;AAjBD,WAAY,YAAY;IACpB,yDAAS,CAAA;IAET,qDAAqD;IACrD,2DAA2D;IAC3D,qCAAqC;IACrC,iFAAqB,CAAA;IAErB,wDAAwD;IACxD,0DAA0D;IAC1D,2BAA2B;IAC3B,2FAA0B,CAAA;IAE1B,2DAA2D;IAC3D,2DAA2D;IAC3D,SAAS;IACT,iFAAqB,CAAA;AACzB,CAAC,EAjBW,YAAY,4BAAZ,YAAY,QAiBvB;AAgDD,IAAkB,eA8EjB;AA9ED,WAAkB,eAAe;IAC7B,2DAAW,CAAA;IAEX,8DAA8D;IAC9D,0BAA0B;IAC1B,+DAAkB,CAAA;IAElB,2DAA2D;IAC3D,yDAAyD;IACzD,iDAAiD;IACjD,uEAAsB,CAAA;IAEtB,sEAAsE;IACtE,sEAAsE;IACtE,6DAA6D;IAC7D,yFAA+B,CAAA;IAE/B,kEAAkE;IAClE,sEAAsE;IACtE,0BAA0B;IAC1B,yFAA+B,CAAA;IAE/B,sDAAsD;IACtD,4DAA4D;IAC5D,4DAA4D;IAC5D,uCAAuC;IACvC,4EAAwB,CAAA;IAExB,2DAA2D;IAC3D,2DAA2D;IAC3D,8BAA8B;IAC9B,0FAA+B,CAAA;IAE/B,kDAAkD;IAClD,oFAA4B,CAAA;IAE5B,2DAA2D;IAC3D,uDAAuD;IACvD,+FAAiC,CAAA;IAEjC,6DAA6D;IAC7D,mEAAmE;IACnE,mEAAmE;IACnE,UAAU;IACV,uFAA6B,CAAA;IAE7B,oEAAoE;IACpE,kEAAkE;IAClE,mEAAmE;IACnE,iEAAiE;IACjE,wFAA8B,CAAA;IAE9B,uEAAuE;IACvE,gDAAgD;IAChD,8GAAyC,CAAA;IAEzC,sEAAsE;IACtE,kEAAkE;IAClE,gEAAgE;IAChE,aAAa;IACb,gGAAkC,CAAA;IAElC,mEAAmE;IACnE,gEAAgE;IAChE,sBAAsB;IACtB,uGAAqC,CAAA;IAErC,0EAA0E;IAC1E,kEAAkE;IAClE,2FAA+B,CAAA;IAE/B,yEAAyE;IACzE,kCAAkC;IAClC,iGAAkC,CAAA;IAElC,uEAAuE;IACvE,sEAAsE;IACtE,kGAAkC,CAAA;AACtC,CAAC,EA9EiB,eAAe,+BAAf,eAAe,QA8EhC"}

package/dist/analyzer/typeGuards.d.ts

@@ -1,4 +1,5 @@
 import { ExpressionNode } from '../parser/parseNodes';
+import { AnalyzerNodeInfoAccessor } from './analyzerNodeInfo';
 import { TypeEvaluator } from './typeEvaluatorTypes';
 import { AnyType, ClassType, FunctionType, OverloadedType, Type, TypeVarType, UnknownType } from './types';
 export interface TypeNarrowingResult {
@@ -6,9 +7,9 @@ export interface TypeNarrowingResult {
     isIncomplete: boolean;
 }
 export type TypeNarrowingCallback = (type: Type) => TypeNarrowingResult | undefined;
-export declare function getTypeNarrowingCallback(evaluator: TypeEvaluator, reference: ExpressionNode, testExpression: ExpressionNode, isPositiveTest: boolean, recursionCount?: number): TypeNarrowingCallback | undefined;
+export declare function getTypeNarrowingCallback(evaluator: TypeEvaluator, reference: ExpressionNode, testExpression: ExpressionNode, isPositiveTest: boolean, nodeInfo: AnalyzerNodeInfoAccessor, recursionCount?: number): TypeNarrowingCallback | undefined;
 export declare function getIsInstanceClassTypes(evaluator: TypeEvaluator, argType: Type): (ClassType | TypeVarType | FunctionType)[] | undefined;
-export declare function narrowTypeForInstanceOrSubclass(evaluator: TypeEvaluator, type: Type, filterTypes: Type[], isInstanceCheck: boolean, isTypeIsCheck: boolean, isPositiveTest: boolean, errorNode: ExpressionNode): import("./types").UnboundType | UnknownType | AnyType | FunctionType | OverloadedType | ClassType | import("./types").ModuleType | TypeVarType | import("./types").NeverType | import("./types").UnionType;
+export declare function narrowTypeForInstanceOrSubclass(evaluator: TypeEvaluator, type: Type, filterTypes: Type[], isInstanceCheck: boolean, isTypeIsCheck: boolean, isPositiveTest: boolean, errorNode: ExpressionNode, nodeInfo: AnalyzerNodeInfoAccessor): import("./types").UnboundType | UnknownType | AnyType | FunctionType | OverloadedType | ClassType | import("./types").ModuleType | TypeVarType | import("./types").NeverType | import("./types").UnionType;
 export declare function getElementTypeForContainerNarrowing(containerType: Type): Type | undefined;
 export declare function narrowTypeForContainerElementType(evaluator: TypeEvaluator, referenceType: Type, elementType: Type): Type;
 export declare function narrowTypeForDiscriminatedDictEntryComparison(evaluator: TypeEvaluator, referenceType: Type, indexLiteralType: ClassType, literalType: Type, isPositiveTest: boolean): Type;

package/dist/analyzer/typeGuards.js

@@ -68,13 +68,13 @@ const typeUtils_1 = require("./typeUtils");
 // can be used to narrow the type described by the reference expression.
 // If the specified flow node is not associated with the test expression,
 // it returns undefined.
-function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositiveTest, recursionCount = 0) {
+function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositiveTest, nodeInfo, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return undefined;
     }
     recursionCount++;
     if (testExpression.nodeType === 4 /* ParseNodeType.AssignmentExpression */) {
-        return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount);
+        return getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, nodeInfo, recursionCount);
     }
     if (testExpression.nodeType === 7 /* ParseNodeType.BinaryOperation */) {
         const isOrIsNotOperator = testExpression.d.operator === 39 /* OperatorType.Is */ || testExpression.d.operator === 40 /* OperatorType.IsNot */;
@@ -422,7 +422,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         return (type) => {
                             return {
                                 type: narrowTypeForInstanceOrSubclass(evaluator, type, classTypeList, isInstanceCheck, 
-                                /* isTypeIsCheck */ false, isPositiveTest, testExpression),
+                                /* isTypeIsCheck */ false, isPositiveTest, testExpression, nodeInfo),
                                 isIncomplete,
                             };
                         };
@@ -462,9 +462,23 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 // Does this look like it's a custom type guard function?
                 let isPossiblyTypeGuard = false;
                 const isFunctionReturnTypeGuard = (type) => {
-                    return (type.shared.declaredReturnType &&
-                        (0, types_1.isClassInstance)(type.shared.declaredReturnType) &&
-                        types_1.ClassType.isBuiltIn(type.shared.declaredReturnType, ['TypeGuard', 'TypeIs']));
+                    const returnType = type.shared.declaredReturnType;
+                    if (!returnType) {
+                        return false;
+                    }
+                    if ((0, types_1.isClassInstance)(returnType)) {
+                        return types_1.ClassType.isBuiltIn(returnType, ['TypeGuard', 'TypeIs']);
+                    }
+                    if ((0, types_1.isUnion)(returnType)) {
+                        let isAllGuards = true;
+                        (0, typeUtils_1.doForEachSubtype)(returnType, (subtype) => {
+                            if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs'])) {
+                                isAllGuards = false;
+                            }
+                        });
+                        return isAllGuards;
+                    }
+                    return false;
                 };
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
                 const callType = callTypeResult.type;
@@ -482,16 +496,42 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     // Evaluate the type guard call expression.
                     const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
                     const functionReturnType = functionReturnTypeResult.type;
+                    let typeGuardType;
+                    let isStrictTypeGuard = false;
                     if ((0, types_1.isClassInstance)(functionReturnType) &&
                         types_1.ClassType.isBuiltIn(functionReturnType, ['TypeGuard', 'TypeIs']) &&
                         functionReturnType.priv.typeArgs &&
                         functionReturnType.priv.typeArgs.length > 0) {
-                        const isStrictTypeGuard = types_1.ClassType.isBuiltIn(functionReturnType, 'TypeIs');
-                        const typeGuardType = functionReturnType.priv.typeArgs[0];
+                        isStrictTypeGuard = types_1.ClassType.isBuiltIn(functionReturnType, 'TypeIs');
+                        typeGuardType = functionReturnType.priv.typeArgs[0];
+                    }
+                    else if ((0, types_1.isUnion)(functionReturnType)) {
+                        const typeGuardSubtypes = [];
+                        let isAllGuards = true;
+                        (0, typeUtils_1.doForEachSubtype)(functionReturnType, (subtype) => {
+                            if ((0, types_1.isClassInstance)(subtype) &&
+                                types_1.ClassType.isBuiltIn(subtype, ['TypeGuard', 'TypeIs']) &&
+                                subtype.priv.typeArgs &&
+                                subtype.priv.typeArgs.length > 0) {
+                                typeGuardSubtypes.push(subtype);
+                            }
+                            else {
+                                isAllGuards = false;
+                            }
+                        });
+                        if (isAllGuards && typeGuardSubtypes.length > 0) {
+                            // A union of type guards cannot be strict in the negative case because at runtime
+                            // only one arm of the overload/union is selected. Treating it as strict would
+                            // unsoundly eliminate types in the negative branch.
+                            isStrictTypeGuard = false;
+                            typeGuardType = (0, types_1.combineTypes)(typeGuardSubtypes.map((subtype) => subtype.priv.typeArgs[0]));
+                        }
+                    }
+                    if (typeGuardType) {
                         const isIncomplete = !!callTypeResult.isIncomplete || !!functionReturnTypeResult.isIncomplete;
                         return (type) => {
                             return {
-                                type: narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, testExpression),
+                                type: narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, testExpression, nodeInfo),
                                 isIncomplete,
                             };
                         };
@@ -510,7 +550,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     }
     // Is this a reference to an aliased conditional expression (a local variable
     // that was assigned a value that can inform type narrowing of the reference expression)?
-    const narrowingCallback = getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount);
+    const narrowingCallback = getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, nodeInfo, recursionCount);
     if (narrowingCallback) {
         return narrowingCallback;
     }
@@ -520,12 +560,12 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     if (reference.nodeType === 38 /* ParseNodeType.Name */) {
         if (testExpression.nodeType === 55 /* ParseNodeType.UnaryOperation */ &&
             testExpression.d.operator === 38 /* OperatorType.Not */) {
-            return getTypeNarrowingCallback(evaluator, reference, testExpression.d.expr, !isPositiveTest, recursionCount);
+            return getTypeNarrowingCallback(evaluator, reference, testExpression.d.expr, !isPositiveTest, nodeInfo, recursionCount);
         }
     }
     return undefined;
 }
-function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
+function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, nodeInfo, recursionCount) {
     if (testExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
         reference.nodeType !== 38 /* ParseNodeType.Name */ ||
         testExpression === reference) {
@@ -571,13 +611,14 @@ function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testE
     if (!initNode || ParseTreeUtils.isNodeContainedWithin(testExpression, initNode) || !(0, parseNodes_1.isExpressionNode)(initNode)) {
         return undefined;
     }
-    return getTypeNarrowingCallback(evaluator, reference, initNode, isPositiveTest, recursionCount);
+    return getTypeNarrowingCallback(evaluator, reference, initNode, isPositiveTest, nodeInfo, recursionCount);
 }
 // Determines whether the symbol is a local variable or parameter within
 // the current scope. If requireUnique is true, there can be only one
 // declaration (assignment) of the symbol, otherwise it is rejected.
 function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
-    const scope = (0, scopeUtils_1.getScopeForNode)(name);
+    const nodeInfo = (0, analyzerNodeInfo_1.getInfoReader)(evaluator);
+    const scope = (0, scopeUtils_1.getScopeForNode)(name, nodeInfo);
     if (scope?.type !== 2 /* ScopeType.Function */ && scope?.type !== 4 /* ScopeType.Module */) {
         return undefined;
     }
@@ -598,7 +639,7 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
     let prevDeclScope;
     if (decls.some((decl) => {
         const nodeToConsider = decl.type === 2 /* DeclarationType.Param */ ? decl.node.d.name : decl.node;
-        const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider);
+        const declScopeNode = ParseTreeUtils.getExecutionScopeNode(nodeToConsider, nodeInfo);
         if (prevDeclScope && declScopeNode !== prevDeclScope) {
             return true;
         }
@@ -610,11 +651,11 @@ function getDeclsForLocalVar(evaluator, name, reachableFrom, requireUnique) {
     const reachableDecls = decls.filter((decl) => evaluator.isNodeReachable(reachableFrom, decl.node));
     return reachableDecls.length > 0 ? reachableDecls : undefined;
 }
-function getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
-    return (getTypeNarrowingCallback(evaluator, reference, testExpression.d.rightExpr, isPositiveTest, recursionCount) ??
-        getTypeNarrowingCallback(evaluator, reference, testExpression.d.name, isPositiveTest, recursionCount));
+function getTypeNarrowingCallbackForAssignmentExpression(evaluator, reference, testExpression, isPositiveTest, nodeInfo, recursionCount) {
+    return (getTypeNarrowingCallback(evaluator, reference, testExpression.d.rightExpr, isPositiveTest, nodeInfo, recursionCount) ??
+        getTypeNarrowingCallback(evaluator, reference, testExpression.d.name, isPositiveTest, nodeInfo, recursionCount));
 }
-function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, errorNode) {
+function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPositiveTest, isStrictTypeGuard, errorNode, nodeInfo) {
     // For non-strict type guards, always narrow to the typeGuardType
     // in the positive case and don't narrow in the negative case.
     if (!isStrictTypeGuard) {
@@ -636,7 +677,7 @@ function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPos
     });
     return narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, 
     /* isInstanceCheck */ true, 
-    /* isTypeIsCheck */ true, isPositiveTest, errorNode);
+    /* isTypeIsCheck */ true, isPositiveTest, errorNode, nodeInfo);
 }
 // Narrow the type based on whether the subtype can be true or false.
 function narrowTypeForTruthiness(evaluator, type, isPositiveTest) {
@@ -896,18 +937,18 @@ function getIsInstanceClassTypes(evaluator, argType) {
     });
     return foundNonClassType ? undefined : classTypeList;
 }
-function narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode) {
+function narrowTypeForInstanceOrSubclass(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode, nodeInfo) {
     // First try with intersection types disallowed.
     const narrowedType = narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
-    /* allowIntersections */ false, errorNode);
+    /* allowIntersections */ false, errorNode, nodeInfo);
     if (!(0, types_1.isNever)(narrowedType)) {
         return narrowedType;
     }
     // Try again with intersection types allowed.
     return narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
-    /* allowIntersections */ true, errorNode);
+    /* allowIntersections */ true, errorNode, nodeInfo);
 }
-function narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode) {
+function narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode, nodeInfo) {
     const result = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
         let adjSubtype = subtype;
         let resultRequiresAdj = false;
@@ -925,7 +966,7 @@ function narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, i
                 }
             }
         }
-        const narrowedResult = narrowTypeForInstance(evaluator, adjSubtype, adjFilterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode);
+        const narrowedResult = narrowTypeForInstance(evaluator, adjSubtype, adjFilterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode, nodeInfo);
         if (!resultRequiresAdj) {
             return narrowedResult;
         }
@@ -943,7 +984,7 @@ function narrowTypeForInstanceOrSubclassInternal(evaluator, type, filterTypes, i
 // type of expression "x" is "Mammal" and the test expression is
 // "isinstance(x, Cow)", (assuming "Cow" is a subclass of "Mammal"), we can
 // narrow x to "Cow".
-function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode) {
+function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPositiveTest, allowIntersections, errorNode, nodeInfo) {
     let expandedTypes = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
@@ -955,7 +996,7 @@ function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPo
         }
         // If this is an isinstance or issubclass check, the type variables
         // should be converted to "free" type variables.
-        return (0, typeUtils_1.makeTypeVarsFree)(varType, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+        return (0, typeUtils_1.makeTypeVarsFree)(varType, ParseTreeUtils.getTypeVarScopesForNode(errorNode, nodeInfo));
     };
     // Filters the varType by the parameters of the isinstance
     // and returns the list of types the varType could be after
@@ -1001,7 +1042,7 @@ function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPo
                 // bound to free type variables. We'll retain the bound type
                 // variables for TypeIs checks.
                 if (!isTypeIsCheck) {
-                    runtimeVarType = (0, typeUtils_1.makeTypeVarsFree)(runtimeVarType, ParseTreeUtils.getTypeVarScopesForNode(errorNode));
+                    runtimeVarType = (0, typeUtils_1.makeTypeVarsFree)(runtimeVarType, ParseTreeUtils.getTypeVarScopesForNode(errorNode, nodeInfo));
                 }
                 // If the value is a TypedDict, convert it into its runtime form,
                 // which is a dict[str, Any].
@@ -1189,7 +1230,7 @@ function narrowTypeForInstance(evaluator, type, filterTypes, isTypeIsCheck, isPo
                     // two type is a subclass that is callable. We'll synthesize a
                     // new intersection type.
                     const className = `<callable subtype of ${concreteVarType.shared.name}>`;
-                    const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
                     let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), 
                     /* declaredMetaclass */ undefined, concreteVarType.shared.effectiveMetaclass, concreteVarType.shared.docString);
                     newClassType.shared.baseClasses = [concreteVarType];
@@ -1571,7 +1612,8 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
         }
         if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
             const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
-            const tdEntry = entries.knownItems.get(literalKey.priv.literalValue) ?? entries.extraItems;
+            const knownEntry = entries.knownItems.get(literalKey.priv.literalValue);
+            const tdEntry = knownEntry ?? entries.extraItems;
             if (isPositiveTest) {
                 // The code that is commented out below implements the behavior that is technically
                 // correct, but until we PEP 728 is ratified and we have a way to express "extra items"
@@ -1612,7 +1654,14 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                 return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForNarrowedTypedDictEntries(types_1.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
             }
             else {
-                return tdEntry !== undefined && (tdEntry.isRequired || tdEntry.isProvided) ? undefined : subtype;
+                if (!knownEntry) {
+                    // The key is not one of the known items, so it can be supplied
+                    // only through an "extra items" entry, which says nothing about
+                    // whether this particular key is present. Its absence is therefore
+                    // consistent with the type, and the subtype cannot be eliminated.
+                    return subtype;
+                }
+                return knownEntry.isRequired || knownEntry.isProvided ? undefined : subtype;
             }
         }
         return subtype;
@@ -1894,6 +1943,52 @@ function isFilterSuperclass(varType, concreteVarType, filterType, concreteFilter
     }
     return false;
 }
+// Determines whether the specified class is an enum class whose members derive
+// from a primitive type (e.g. IntEnum or StrEnum). Members of such classes
+// compare equal to their underlying primitive value at runtime.
+function isPrimitiveBackedEnumClass(classType) {
+    if (!types_1.ClassType.isEnumClass(classType)) {
+        return false;
+    }
+    return (0, typeUtils_1.derivesFromStdlibClass)(classType, 'int') || (0, typeUtils_1.derivesFromStdlibClass)(classType, 'str');
+}
+// Determines whether enumType is a primitive-backed enum class and primitiveType
+// is the primitive type (int or str) from which it derives.
+function isPrimitiveBackedEnumAndPrimitive(enumType, primitiveType) {
+    if (types_1.ClassType.isEnumClass(primitiveType) || !isPrimitiveBackedEnumClass(enumType)) {
+        return false;
+    }
+    // Exclude bool, which derives from int but whose literal values are distinct
+    // from the corresponding int literals.
+    if (types_1.ClassType.isBuiltIn(primitiveType, 'int')) {
+        return (0, typeUtils_1.derivesFromStdlibClass)(enumType, 'int');
+    }
+    if (types_1.ClassType.isBuiltIn(primitiveType, 'str')) {
+        return (0, typeUtils_1.derivesFromStdlibClass)(enumType, 'str');
+    }
+    return false;
+}
+// If the specified type is a literal member of a primitive-backed enum class,
+// returns the corresponding primitive literal type. Otherwise returns the type
+// unmodified.
+function unwrapPrimitiveBackedEnumLiteral(classType) {
+    const literalValue = classType.priv.literalValue;
+    if (!(literalValue instanceof types_1.EnumLiteral) || !isPrimitiveBackedEnumClass(classType)) {
+        return classType;
+    }
+    const itemType = literalValue.itemType;
+    if ((0, types_1.isClassInstance)(itemType) && itemType.priv.literalValue !== undefined) {
+        return itemType;
+    }
+    return classType;
+}
+// Determines whether two literal types compare equal using the `==` operator at
+// runtime. This differs from ClassType.isLiteralValueSame only for members of
+// primitive-backed enum classes, which compare equal to their underlying
+// primitive values.
+function isLiteralValueEqualAtRuntime(type1, type2) {
+    return types_1.ClassType.isLiteralValueSame(unwrapPrimitiveBackedEnumLiteral(type1), unwrapPrimitiveBackedEnumLiteral(type2));
+}
 // Attempts to narrow a type (make it more constrained) based on a comparison
 // (equal or not equal) to a literal value. It also handles "is" or "is not"
 // operators if isIsOperator is true.
@@ -1906,9 +2001,20 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
             }
             return subtype;
         }
-        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
+        // Determine whether this is a comparison between a primitive-backed enum
+        // (e.g. IntEnum or StrEnum) and its underlying primitive type. Such a
+        // comparison can be used for narrowing because the enum member compares
+        // equal to its underlying primitive value at runtime.
+        const isPrimitiveBackedEnumComparison = !isIsOperator &&
+            (0, types_1.isClassInstance)(subtype) &&
+            (isPrimitiveBackedEnumAndPrimitive(subtype, literalType) ||
+                isPrimitiveBackedEnumAndPrimitive(literalType, subtype));
+        if ((0, types_1.isClassInstance)(subtype) &&
+            (types_1.ClassType.isSameGenericClass(literalType, subtype) || isPrimitiveBackedEnumComparison)) {
             if (subtype.priv.literalValue !== undefined) {
-                const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
+                const literalValueMatches = isPrimitiveBackedEnumComparison
+                    ? isLiteralValueEqualAtRuntime(subtype, literalType)
+                    : types_1.ClassType.isLiteralValueSame(subtype, literalType);
                 if (isPositiveTest) {
                     return literalValueMatches ? subtype : undefined;
                 }
@@ -1920,13 +2026,31 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
                 return literalValueMatches && (isSingleton || !isIsOperator) ? undefined : subtype;
             }
             if (isPositiveTest) {
+                if (isPrimitiveBackedEnumComparison) {
+                    // If the reference type is the enum, attempt to find the member
+                    // whose value matches the primitive literal. If no member can be
+                    // identified (e.g. for an IntFlag class, whose members cannot be
+                    // enumerated), retain the reference type rather than narrowing it
+                    // to the primitive literal type.
+                    if (types_1.ClassType.isEnumClass(subtype)) {
+                        const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
+                        const match = allLiteralTypes?.find((type) => isLiteralValueEqualAtRuntime(type, literalType));
+                        return match ?? subtype;
+                    }
+                    // The reference type is the primitive type, so narrowing it to the
+                    // enum literal would lose its (potentially derived) class. Retain
+                    // the reference type instead.
+                    return subtype;
+                }
                 return literalType;
             }
             // If we're able to enumerate all possible literal values
             // (for bool or enum), we can eliminate all others in a negative test.
             const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
             if (allLiteralTypes && allLiteralTypes.length > 0) {
-                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
+                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => isPrimitiveBackedEnumComparison
+                    ? !isLiteralValueEqualAtRuntime(type, literalType)
+                    : !types_1.ClassType.isLiteralValueSame(type, literalType)));
             }
             return subtype;
         }
@@ -1967,7 +2091,7 @@ function enumerateLiteralsForType(evaluator, type) {
         fields.forEach((symbol, name) => {
             if (!symbol.isIgnoredForProtocolMatch()) {
                 let symbolType = evaluator.getEffectiveTypeOfSymbol(symbol);
-                symbolType = (0, enums_1.transformTypeForEnumMember)(evaluator, type, name) ?? symbolType;
+                symbolType = (0, enums_1.transformTypeForEnumMember)(evaluator, type, name, (0, analyzerNodeInfo_1.getInfoReader)(evaluator)) ?? symbolType;
                 if ((0, types_1.isClassInstance)(symbolType) &&
                     types_1.ClassType.isSameGenericClass(type, symbolType) &&
                     symbolType.priv.literalValue !== undefined) {