@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260823

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":";AAAA;;;;;;;GAOG;;;AA0ZH,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"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":"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"}

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,
                             };
                         };
@@ -491,7 +491,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         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 +510,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 +520,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 +571,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 +599,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 +611,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 +637,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 +897,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 +926,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 +944,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 +956,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 +1002,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 +1190,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];
@@ -1588,11 +1589,13 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                 //     // narrowing it isn't possible in this case.
                 //     return subtype;
                 // }
-                // if (isNever(tdEntry.valueType)) {
-                //     // If the entry is typed as Never or the "extra items" is typed as Never,
-                //     // then this key cannot be present in the TypedDict, and we can eliminate it.
-                //     return undefined;
-                // }
+                if ((0, types_1.isNever)(tdEntry.valueType)) {
+                    // If the entry is typed as Never or the "extra items" is typed as Never,
+                    // then this key cannot be present in the TypedDict, and we can eliminate it.
+                    // A closed TypedDict has an "extra items" of Never, so this is what allows
+                    // a key check to discriminate between closed TypedDicts.
+                    return undefined;
+                }
                 // If the entry is currently not required and not marked provided, we can mark
                 // it as provided after this guard expression confirms it is.
                 if (tdEntry.isRequired || tdEntry.isProvided) {
@@ -1953,9 +1956,10 @@ function enumerateLiteralsForType(evaluator, type) {
         ];
     }
     if (types_1.ClassType.isEnumClass(type)) {
-        // Enum expansion doesn't apply to enum classes that derive
-        // from enum.Flag.
-        if (type.shared.baseClasses.some((baseClass) => (0, types_1.isClass)(baseClass) && types_1.ClassType.isBuiltIn(baseClass, 'Flag'))) {
+        // Enum expansion doesn't apply if the member set cannot be statically
+        // enumerated or if the class derives from enum.Flag.
+        if (types_1.ClassType.isEnumMemberSetMayBeDynamicallyModified(type) ||
+            type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'Flag'))) {
             return undefined;
         }
         // Enumerate all of the values in this enumeration.
@@ -1964,7 +1968,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) {