@zzzen/pyright-internal 1.2.0-dev.20240728 → 1.2.0-dev.20240811

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -6,14 +6,14 @@ import { TextRange } from '../common/textRange';
 import { ArgCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParamCategory, ParameterNode, ParseNode, RaiseNode, StringNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import { CodeFlowReferenceExpressionNode, FlowNode } from './codeFlowTypes';
+import { ConstraintTracker } from './constraintTracker';
 import { Declaration } from './declaration';
 import * as DeclarationUtils from './declarationUtils';
 import { SymbolWithScope } from './scope';
 import { Symbol } from './symbol';
 import { PrintTypeFlags } from './typePrinter';
+import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedType, Type, TypeCondition, TypeVarScopeId, TypeVarType, UnknownType, Variance } from './types';
 import { AssignTypeFlags, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
-import { TypeVarContext } from './typeVarContext';
-import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarType, UnknownType, Variance } from './types';
 export declare const maxSubtypesForInferredType = 64;
 export declare const enum EvalFlags {
     None = 0,
@@ -68,6 +68,7 @@ export interface TypeResult<T extends Type = Type> {
     isReadOnly?: boolean;
     overloadsUsedForCall?: FunctionType[];
     memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
+    magicMethodDeprecationInfo?: MagicMethodDeprecationInfo;
 }
 export interface TypeResultWithNode extends TypeResult {
     node: ParseNode;
@@ -77,6 +78,11 @@ export interface MemberAccessDeprecationInfo {
     accessMethod: 'get' | 'set' | 'del';
     deprecatedMessage: string;
 }
+export interface MagicMethodDeprecationInfo {
+    className: string;
+    methodName: string;
+    deprecatedMessage: string;
+}
 export interface EvaluatorUsage {
     method: 'get' | 'set' | 'del';
     setType?: TypeResult | undefined;
@@ -174,7 +180,6 @@ export interface ArgResult {
     argType: Type;
     isTypeIncomplete?: boolean | undefined;
     condition?: TypeCondition[];
-    skippedOverloadArg?: boolean;
     skippedBareTypeVarExpectedType?: boolean;
 }
 export interface CallResult {
@@ -199,6 +204,19 @@ export interface ClassMemberLookup {
     narrowedTypeForSet?: Type;
     memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
 }
+export interface SolveConstraintsOptions {
+    useLowerBoundOnly?: boolean;
+}
+export interface ApplyTypeVarOptions {
+    typeClassType?: ClassType;
+    replaceUnsolved?: {
+        scopeIds: TypeVarScopeId[];
+        tupleClassType: ClassType | undefined;
+        unsolvedExemptTypeVars?: TypeVarType[];
+        useUnknown?: boolean;
+        eliminateUnsolvedInUnions?: boolean;
+    };
+}
 export declare enum Reachability {
     Reachable = 0,
     UnreachableAlways = 1,
@@ -260,10 +278,11 @@ export interface TypeEvaluator {
     removeTruthinessFromType: (type: Type) => Type;
     removeFalsinessFromType: (type: Type) => Type;
     stripTypeGuard: (type: Type) => Type;
+    solveAndApplyConstraints: (type: Type, constraints: ConstraintTracker, applyOptions?: ApplyTypeVarOptions, solveOptions?: SolveConstraintsOptions) => Type;
     getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
     verifyRaiseExceptionType: (node: RaiseNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
-    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedFunctionType>, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
+    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedType>, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
     validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
     isNodeReachable: (node: ParseNode, sourceNode?: ParseNode | undefined) => boolean;
     isAfterNodeReachable: (node: ParseNode) => boolean;
@@ -294,19 +313,19 @@ export interface TypeEvaluator {
     getDeclaredTypeForExpression: (expression: ExpressionNode, usage?: EvaluatorUsage) => Type | undefined;
     getFunctionDeclaredReturnType: (node: FunctionNode) => Type | undefined;
     getFunctionInferredReturnType: (type: FunctionType, callSiteInfo?: CallSiteEvaluationInfo) => Type;
-    getBestOverloadForArgs: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedFunctionType>, argList: Arg[]) => FunctionType | undefined;
+    getBestOverloadForArgs: (errorNode: ExpressionNode, typeResult: TypeResult<OverloadedType>, argList: Arg[]) => FunctionType | undefined;
     getBuiltInType: (node: ParseNode, name: string) => Type;
     getTypeOfMember: (member: ClassMember) => Type;
     getTypeOfBoundMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, flags?: MemberAccessFlags, selfType?: ClassType | TypeVarType): TypeResult | undefined;
-    getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
-    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => Type | undefined;
-    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedFunctionType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | undefined;
+    getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
+    getTypeOfMagicMethodCall: (objType: Type, methodName: string, argList: TypeResult[], errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => TypeResult | undefined;
+    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
     getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
     getAbstractSymbols: (classType: ClassType) => AbstractSymbol[];
     narrowConstrainedTypeVar: (node: ParseNode, typeVar: TypeVarType) => Type | undefined;
-    assignType: (destType: Type, srcType: Type, diag?: DiagnosticAddendum, destTypeVarContext?: TypeVarContext, srcTypeVarContext?: TypeVarContext, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
-    validateOverrideMethod: (baseMethod: Type, overrideMethod: FunctionType | OverloadedFunctionType, baseClass: ClassType | undefined, diag: DiagnosticAddendum, enforceParamNames?: boolean) => boolean;
-    validateCallArgs: (errorNode: ExpressionNode, argList: Arg[], callTypeResult: TypeResult, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined) => CallResult;
+    assignType: (destType: Type, srcType: Type, diag?: DiagnosticAddendum, constraints?: ConstraintTracker, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
+    validateOverrideMethod: (baseMethod: Type, overrideMethod: FunctionType | OverloadedType, baseClass: ClassType | undefined, diag: DiagnosticAddendum, enforceParamNames?: boolean) => boolean;
+    validateCallArgs: (errorNode: ExpressionNode, argList: Arg[], callTypeResult: TypeResult, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined) => CallResult;
     validateTypeArg: (argResult: TypeResultWithNode, options?: ValidateTypeArgsOptions) => boolean;
     assignTypeToExpression: (target: ExpressionNode, typeResult: TypeResult, srcExpr: ExpressionNode) => void;
     assignClassToSelf: (destType: ClassType, srcType: ClassType, assumedVariance: Variance) => boolean;
@@ -320,7 +339,7 @@ export interface TypeEvaluator {
     getTypingType: (node: ParseNode, symbolName: string) => Type | undefined;
     inferReturnTypeIfNecessary: (type: Type) => void;
     inferVarianceForClass: (type: ClassType) => void;
-    assignTypeArgs: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, destTypeVarContext: TypeVarContext | undefined, srcTypeVarContext: TypeVarContext | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
+    assignTypeArgs: (destType: ClassType, srcType: ClassType, diag: DiagnosticAddendum | undefined, constraints: ConstraintTracker | undefined, flags: AssignTypeFlags, recursionCount: number) => boolean;
     reportMissingTypeArgs: (node: ExpressionNode, type: Type, flags: EvalFlags) => Type;
     isFinalVariable: (symbol: Symbol) => boolean;
     isFinalVariableDeclaration: (decl: Declaration) => boolean;
@@ -344,5 +363,4 @@ export interface TypeEvaluator {
     setTypeResultForNode: (node: ParseNode, typeResult: TypeResult, flags?: EvalFlags) => void;
     checkForCancellation: () => void;
     printControlFlowGraph: (flowNode: FlowNode, reference: CodeFlowReferenceExpressionNode | undefined, callName: string, logger: ConsoleInterface) => void;
-    printTypeVarContext: (typeVarContext: TypeVarContext) => void;
 }

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AA+CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,SAgIjB;AAhID,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,mDAAmD;IACnD,uEAA2B,CAAA;IAE3B,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6EAA6B,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,8CAA8C;IAC9C,0FAAkC,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,EAhIiB,SAAS,yBAAT,SAAS,QAgI1B;AA8PD,IAAY,YAIX;AAJD,WAAY,YAAY;IACpB,yDAAS,CAAA;IACT,yEAAiB,CAAA;IACjB,iFAAqB,CAAA;AACzB,CAAC,EAJW,YAAY,4BAAZ,YAAY,QAIvB"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAgDH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,SAgIjB;AAhID,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,mDAAmD;IACnD,uEAA2B,CAAA;IAE3B,6CAA6C;IAC7C,0DAAoB,CAAA;IAEpB,mEAAmE;IACnE,kEAAwB,CAAA;IAExB,iEAAiE;IACjE,iCAAiC;IACjC,wDAAmB,CAAA;IAEnB,wDAAwD;IACxD,iEAAuB,CAAA;IAEvB,uDAAuD;IACvD,2EAA4B,CAAA;IAE5B,yCAAyC;IACzC,mFAAgC,CAAA;IAEhC,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6EAA6B,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,8CAA8C;IAC9C,0FAAkC,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,EAhIiB,SAAS,yBAAT,SAAS,QAgI1B;AAqRD,IAAY,YAIX;AAJD,WAAY,YAAY;IACpB,yDAAS,CAAA;IACT,yEAAiB,CAAA;IACjB,iFAAqB,CAAA;AACzB,CAAC,EAJW,YAAY,4BAAZ,YAAY,QAIvB"}

package/dist/analyzer/typeEvaluatorWithTracker.js

@@ -9,7 +9,7 @@
  * Wraps type evaluator to track performance of internal calls.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypeEvaluatorWithTracker = void 0;
+exports.createTypeEvaluatorWithTracker = createTypeEvaluatorWithTracker;
 const console_1 = require("../common/console");
 const core_1 = require("../common/core");
 const timing_1 = require("../common/timing");
@@ -58,5 +58,4 @@ function createTypeEvaluatorWithTracker(importLookup, evaluatorOptions, logger,
     });
     return evaluator;
 }
-exports.createTypeEvaluatorWithTracker = createTypeEvaluatorWithTracker;
 //# sourceMappingURL=typeEvaluatorWithTracker.js.map

package/dist/analyzer/typeEvaluatorWithTracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorWithTracker.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorWithTracker.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,+CAA6C;AAC7C,yCAA6C;AAE7C,6CAA+C;AAG/C,mDAAwE;AAExE,sFAAsF;AACtF,SAAgB,8BAA8B,CAC1C,YAA0B,EAC1B,gBAAkC,EAClC,MAAkB,EAClB,OAAsB;IAEtB,SAAS,cAAc,CAAoC,IAAO;QAC9D,oEAAoE;QACpE,kCAAkC;QAClC,IAAI,gBAAgB,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,KAAK,kBAAQ,CAAC,GAAG,EAAE;YAC/D,OAAO,CAAC,GAAG,IAAmB,EAAiB,EAAE;gBAC7C,OAAO,MAAM,CAAC,GAAG,CACb,IAAI,CAAC,IAAI,EACT,CAAC,CAAC,EAAE,EAAE;oBACF,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;wBACjD,mDAAmD;wBACnD,CAAC,CAAC,GAAG,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;qBAClD;yBAAM;wBACH,wBAAwB;wBACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;4BACf,CAAC,CAAC,GAAG,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC7B,CAAC,CAAC,CAAC;qBACN;oBACD,OAAO,oBAAW,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;gBACvE,CAAC,EACD,gBAAgB,CAAC,uBAAuB;gBACxC,oBAAoB,CAAC,IAAI,CAC5B,CAAC;YACN,CAAC,CAAC;SACL;aAAM,IAAI,CAAC,IAAA,kBAAW,GAAE,EAAE;YACvB,OAAO,oBAAW,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,oBAAW,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;SAClG;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;IAED,sDAAsD;IACtD,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,IAAA,mCAAmB,EAAC,YAAY,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;IAEtF,qFAAqF;IACrF,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;QACf,MAAM,KAAK,GAAI,SAAiB,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,EAAE;YAC3C,mDAAmD;YAClD,SAAiB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;SACjD;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC;AACrB,CAAC;AAnDD,wEAmDC"}
+{"version":3,"file":"typeEvaluatorWithTracker.js","sourceRoot":"","sources":["../../../../../src/analyzer/typeEvaluatorWithTracker.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAWH,wEAmDC;AA5DD,+CAA6C;AAC7C,yCAA6C;AAE7C,6CAA+C;AAG/C,mDAAwE;AAExE,sFAAsF;AACtF,SAAgB,8BAA8B,CAC1C,YAA0B,EAC1B,gBAAkC,EAClC,MAAkB,EAClB,OAAsB;IAEtB,SAAS,cAAc,CAAoC,IAAO;QAC9D,oEAAoE;QACpE,kCAAkC;QAClC,IAAI,gBAAgB,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,KAAK,kBAAQ,CAAC,GAAG,EAAE,CAAC;YAChE,OAAO,CAAC,GAAG,IAAmB,EAAiB,EAAE;gBAC7C,OAAO,MAAM,CAAC,GAAG,CACb,IAAI,CAAC,IAAI,EACT,CAAC,CAAC,EAAE,EAAE;oBACF,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAClD,mDAAmD;wBACnD,CAAC,CAAC,GAAG,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACnD,CAAC;yBAAM,CAAC;wBACJ,wBAAwB;wBACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;4BACf,CAAC,CAAC,GAAG,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC7B,CAAC,CAAC,CAAC;oBACP,CAAC;oBACD,OAAO,oBAAW,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;gBACvE,CAAC,EACD,gBAAgB,CAAC,uBAAuB;gBACxC,oBAAoB,CAAC,IAAI,CAC5B,CAAC;YACN,CAAC,CAAC;QACN,CAAC;aAAM,IAAI,CAAC,IAAA,kBAAW,GAAE,EAAE,CAAC;YACxB,OAAO,oBAAW,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,oBAAW,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;QACnG,CAAC;aAAM,CAAC;YACJ,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAED,sDAAsD;IACtD,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,IAAA,mCAAmB,EAAC,YAAY,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;IAEtF,qFAAqF;IACrF,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;QACf,MAAM,KAAK,GAAI,SAAiB,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,OAAO,KAAK,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YAC5C,mDAAmD;YAClD,SAAiB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC;AACrB,CAAC"}

package/dist/analyzer/typeGuards.js

@@ -33,11 +33,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.func1 = exports.Tree = exports.Plant = exports.Dog = exports.Animal = exports.enumerateLiteralsForType = exports.narrowTypeForDiscriminatedLiteralFieldComparison = exports.narrowTypeForDiscriminatedTupleComparison = exports.narrowTypeForDiscriminatedDictEntryComparison = exports.narrowTypeForContainerElementType = exports.getElementTypeForContainerNarrowing = exports.isIsinstanceFilterSubclass = exports.isIsinstanceFilterSuperclass = exports.getTypeNarrowingCallback = void 0;
+exports.Tree = exports.Plant = exports.Dog = exports.Animal = void 0;
+exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
+exports.isIsinstanceFilterSuperclass = isIsinstanceFilterSuperclass;
+exports.isIsinstanceFilterSubclass = isIsinstanceFilterSubclass;
+exports.getElementTypeForContainerNarrowing = getElementTypeForContainerNarrowing;
+exports.narrowTypeForContainerElementType = narrowTypeForContainerElementType;
+exports.narrowTypeForDiscriminatedDictEntryComparison = narrowTypeForDiscriminatedDictEntryComparison;
+exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTupleComparison;
+exports.narrowTypeForDiscriminatedLiteralFieldComparison = narrowTypeForDiscriminatedLiteralFieldComparison;
+exports.enumerateLiteralsForType = enumerateLiteralsForType;
+exports.func1 = func1;
 const debug_1 = require("../common/debug");
 const parseNodes_1 = require("../parser/parseNodes");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
 const constraintSolver_1 = require("./constraintSolver");
+const constraintTracker_1 = require("./constraintTracker");
 const enums_1 = require("./enums");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const scopeUtils_1 = require("./scopeUtils");
@@ -45,7 +56,6 @@ const symbol_1 = require("./symbol");
 const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
 // Given a reference expression and a test expression, returns a callback that
 // can be used to narrow the type described by the reference expression.
 // If the specified flow node is not associated with the test expression,
@@ -477,8 +487,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
                 }
-                else if ((0, types_1.isOverloadedFunction)(callType) &&
-                    types_1.OverloadedFunctionType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
+                else if ((0, types_1.isOverloaded)(callType) &&
+                    types_1.OverloadedType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
                     isPossiblyTypeGuard = true;
                 }
                 else if ((0, types_1.isClassInstance)(callType)) {
@@ -531,7 +541,6 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
     }
     return undefined;
 }
-exports.getTypeNarrowingCallback = getTypeNarrowingCallback;
 function getTypeNarrowingCallbackForAliasedCondition(evaluator, reference, testExpression, isPositiveTest, recursionCount) {
     if (testExpression.nodeType !== 38 /* ParseNodeType.Name */ ||
         reference.nodeType !== 38 /* ParseNodeType.Name */ ||
@@ -630,7 +639,7 @@ function narrowTypeForUserDefinedTypeGuard(evaluator, type, typeGuardType, isPos
             result = typeGuardType;
             // If the type guard is a non-constrained TypeVar, add a
             // condition to the resulting type.
-            if ((0, types_1.isTypeVar)(type) && !(0, types_1.isParamSpec)(type) && type.shared.constraints.length === 0) {
+            if ((0, types_1.isTypeVar)(type) && !(0, types_1.isParamSpec)(type) && !types_1.TypeVarType.hasConstraints(type)) {
                 result = (0, typeUtils_1.addConditionToType)(result, [{ typeVar: type, constraintIndex: 0 }]);
             }
             return result;
@@ -697,32 +706,40 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     /* options */ undefined, (subtype, unexpandedSubtype) => {
         var _a;
         if ((0, types_1.isAnyOrUnknown)(subtype)) {
-            // We need to assume that "Any" is always both None and not None,
-            // so it matches regardless of whether the test is positive or negative.
+            // Assume that "Any" is always both None and not None, so it matches
+            // regardless of whether the test is positive or negative.
             return subtype;
         }
-        // If this is a TypeVar that isn't constrained, use the unexpanded
-        // TypeVar. For all other cases (including constrained TypeVars),
-        // use the expanded subtype.
-        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
-            ? unexpandedSubtype
-            : subtype;
-        // See if it's a match for object.
-        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
+        let useExpandedSubtype = false;
+        if ((0, types_1.isTypeVar)(unexpandedSubtype) && !types_1.TypeVarType.isSelf(unexpandedSubtype)) {
+            // If the TypeVar has value constraints and one or more of them
+            // are possibly compatible with None, use the expanded subtypes.
+            if (unexpandedSubtype.shared.constraints.some((constraint) => {
+                return evaluator.assignType(constraint, evaluator.getNoneType());
+            })) {
+                useExpandedSubtype = true;
+            }
+            // If the TypeVar han an explicit bound that is possibly compatible
+            // with None (e.g. "T: int | None"), use the expanded subtypes.
+            if (unexpandedSubtype.shared.boundType &&
+                evaluator.assignType(unexpandedSubtype.shared.boundType, evaluator.getNoneType())) {
+                useExpandedSubtype = true;
+            }
+        }
+        const adjustedSubtype = useExpandedSubtype ? subtype : unexpandedSubtype;
+        // Is it an exact match for None?
+        if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+            resultIncludesNoneSubtype = true;
+            return isPositiveTest ? adjustedSubtype : undefined;
+        }
+        // Is it potentially None?
+        if (evaluator.assignType(subtype, evaluator.getNoneType())) {
             resultIncludesNoneSubtype = true;
             return isPositiveTest
                 ? (0, typeUtils_1.addConditionToType)(evaluator.getNoneType(), (_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition)
                 : adjustedSubtype;
         }
-        // See if it's a match for None.
-        if ((0, typeUtils_1.isNoneInstance)(subtype) === isPositiveTest) {
-            resultIncludesNoneSubtype = true;
-            if ((0, types_1.isTypeVar)(adjustedSubtype) && adjustedSubtype.shared.isSynthesizedSelf) {
-                return adjustedSubtype;
-            }
-            return subtype;
-        }
-        return undefined;
+        return isPositiveTest ? undefined : adjustedSubtype;
     });
     // If this is a positive test and the result is a union that includes None,
     // we can eliminate all the non-None subtypes include Any or Unknown. If some
@@ -749,7 +766,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
         // If this is a TypeVar that isn't constrained, use the unexpanded
         // TypeVar. For all other cases (including constrained TypeVars),
         // use the expanded subtype.
-        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.shared.constraints.length === 0
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && !types_1.TypeVarType.hasConstraints(unexpandedSubtype)
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
@@ -853,7 +870,6 @@ function isIsinstanceFilterSuperclass(evaluator, varType, concreteVarType, filte
     }
     return false;
 }
-exports.isIsinstanceFilterSuperclass = isIsinstanceFilterSuperclass;
 function isIsinstanceFilterSubclass(evaluator, varType, concreteFilterType, isInstanceCheck) {
     if (types_1.ClassType.isDerivedFrom(concreteFilterType, varType)) {
         return true;
@@ -869,7 +885,6 @@ function isIsinstanceFilterSubclass(evaluator, varType, concreteFilterType, isIn
     }
     return false;
 }
-exports.isIsinstanceFilterSubclass = isIsinstanceFilterSubclass;
 function narrowTypeForIsInstance(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, errorNode) {
     // First try with intersection types disallowed.
     const narrowedType = narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanceCheck, isTypeIsCheck, isPositiveTest, 
@@ -891,6 +906,15 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
         return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
     });
     expandedTypes = evaluator.expandPromotionTypes(errorNode, expandedTypes);
+    const convertVarTypeToFree = (varType) => {
+        // If this is a TypeIs check, type variables should remain bound.
+        if (isTypeIsCheck) {
+            return varType;
+        }
+        // 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));
+    };
     // Filters the varType by the parameters of the isinstance
     // and returns the list of types the varType could be after
     // applying the filter.
@@ -941,7 +965,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         // If the variable type is a subclass of the isinstance filter,
                         // we haven't learned anything new about the variable type.
                         // If the varType is a Self or type[Self], retain the unnarrowedType.
-                        if ((0, types_1.isTypeVar)(varType) && varType.shared.isSynthesizedSelf) {
+                        if ((0, types_1.isTypeVar)(varType) && types_1.TypeVarType.isSelf(varType)) {
                             filteredTypes.push((0, typeUtils_1.addConditionToType)(varType, conditions));
                         }
                         else {
@@ -949,10 +973,9 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         }
                     }
                     else if (filterIsSubclass) {
-                        if (evaluator.assignType((0, typeUtils_1.convertToInstance)(concreteVarType), (0, typeUtils_1.convertToInstance)(concreteFilterType), 
+                        if (evaluator.assignType((0, typeUtils_1.convertToInstance)(convertVarTypeToFree(concreteVarType)), (0, typeUtils_1.convertToInstance)(concreteFilterType), 
                         /* diag */ undefined, 
-                        /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */ | 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
+                        /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
                             // If the variable type is a superclass of the isinstance
                             // filter, we can narrow the type to the subclass.
                             let specializedFilterType = filterType;
@@ -963,15 +986,17 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                                 if (types_1.ClassType.isSpecialBuiltIn(filterType) || filterType.shared.typeParams.length > 0) {
                                     if (!filterType.priv.isTypeArgExplicit &&
                                         !types_1.ClassType.isSameGenericClass(concreteVarType, filterType)) {
-                                        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
+                                        const constraints = new constraintTracker_1.ConstraintTracker();
                                         const unspecializedFilterType = types_1.ClassType.specialize(filterType, 
                                         /* typeArg */ undefined);
-                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, (0, typeUtils_1.convertToInstance)(unspecializedFilterType), (0, typeUtils_1.convertToInstance)(concreteVarType), typeVarContext, 
+                                        if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluator, (0, typeUtils_1.convertToInstance)(unspecializedFilterType), (0, typeUtils_1.convertToInstance)(concreteVarType), constraints, 
                                         /* liveTypeVarScopes */ undefined, errorNode.start)) {
-                                            specializedFilterType = (0, typeUtils_1.applySolvedTypeVars)(unspecializedFilterType, typeVarContext, {
-                                                unknownIfNotFound: true,
-                                                useUnknownOverDefault: true,
-                                                tupleClassType: evaluator.getTupleClassType(),
+                                            specializedFilterType = evaluator.solveAndApplyConstraints(unspecializedFilterType, constraints, {
+                                                replaceUnsolved: {
+                                                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(filterType),
+                                                    useUnknown: true,
+                                                    tupleClassType: evaluator.getTupleClassType(),
+                                                },
                                             });
                                         }
                                     }
@@ -999,7 +1024,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                         // synthesize a new class type that represents an intersection of
                         // the two types.
                         let newClassType = evaluator.createSubclass(errorNode, concreteVarType, concreteFilterType);
-                        if ((0, types_1.isTypeVar)(varType) && !(0, types_1.isParamSpec)(varType) && varType.shared.constraints.length === 0) {
+                        if ((0, types_1.isTypeVar)(varType) && !(0, types_1.isParamSpec)(varType) && !types_1.TypeVarType.hasConstraints(varType)) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [{ typeVar: varType, constraintIndex: 0 }]);
                         }
                         let newClassObjType = types_1.ClassType.cloneAsInstance(newClassType);
@@ -1074,10 +1099,9 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
                             foundSuperclass = true;
                         }
                     }
-                    else if (evaluator.assignType(concreteVarType, filterType, 
+                    else if (evaluator.assignType(convertVarTypeToFree(concreteVarType), filterType, 
                     /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
+                    /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
                         if (isPositiveTest) {
                             filteredTypes.push(filterType);
                         }
@@ -1115,7 +1139,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
             if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
                 const filterMetaclass = concreteFilterType.shared.effectiveMetaclass;
                 if (filterMetaclass && (0, types_1.isInstantiableClass)(filterMetaclass)) {
-                    let isMetaclassOverlap = evaluator.assignType(metaclassType, types_1.ClassType.cloneAsInstance(filterMetaclass));
+                    let isMetaclassOverlap = evaluator.assignType(convertVarTypeToFree(metaclassType), types_1.ClassType.cloneAsInstance(filterMetaclass));
                     // Handle the special case where the metaclass for the filter is type.
                     // This will normally be treated as type[Any], which is compatible with
                     // any metaclass, but we specifically want to treat type as the class
@@ -1165,10 +1189,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
         if (isPositiveTest) {
             for (const filterType of filterTypes) {
                 const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-                if (evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType), 
-                /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                if (evaluator.assignType(convertVarTypeToFree(varType), (0, typeUtils_1.convertToInstance)(concreteFilterType))) {
                     // If the filter type is a Callable, use the original type. If the
                     // filter type is a callback protocol, use the filter type.
                     if ((0, types_1.isFunction)(filterType)) {
@@ -1187,7 +1208,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
             if ((0, types_1.isClass)(concreteFilterType) && !types_1.ClassType.isProtocolClass(concreteFilterType)) {
                 return false;
             }
-            return evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType));
+            return evaluator.assignType(convertVarTypeToFree(varType), (0, typeUtils_1.convertToInstance)(concreteFilterType));
         })) {
             filteredTypes.push(unexpandedType);
         }
@@ -1249,7 +1270,7 @@ function narrowTypeForIsInstanceInternal(evaluator, type, filterTypes, isInstanc
             if ((0, types_1.isClassInstance)(subtype)) {
                 return (0, types_1.combineTypes)(filterClassType(unexpandedSubtype, types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
             }
-            if (((0, types_1.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) && isInstanceCheck) {
+            if (((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) && isInstanceCheck) {
                 return (0, types_1.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
             }
             if ((0, types_1.isInstantiableClass)(subtype) || isSubtypeMetaclass) {
@@ -1338,7 +1359,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
             !concreteSubtype.priv.tupleTypeArgs) {
             return subtype;
         }
-        // If the tuple contains a variadic TypeVar, we can't narrow it.
+        // If the tuple contains a TypeVarTuple, we can't narrow it.
         if (concreteSubtype.priv.tupleTypeArgs.some((typeArg) => (0, types_1.isUnpackedTypeVarTuple)(typeArg.type))) {
             return subtype;
         }
@@ -1469,7 +1490,6 @@ function getElementTypeForContainerNarrowing(containerType) {
     }
     return elementType;
 }
-exports.getElementTypeForContainerNarrowing = getElementTypeForContainerNarrowing;
 function narrowTypeForContainerElementType(evaluator, referenceType, elementType) {
     let canNarrow = true;
     const elementTypeWithoutLiteral = evaluator.stripLiteralValue(elementType);
@@ -1528,7 +1548,6 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
     });
     return canNarrow ? (0, types_1.combineTypes)([narrowedSupertypes, narrowedSubtypes]) : referenceType;
 }
-exports.narrowTypeForContainerElementType = narrowTypeForContainerElementType;
 // Attempts to narrow a type based on whether it is a TypedDict with
 // a literal key value.
 function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPositiveTest) {
@@ -1604,7 +1623,6 @@ function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType,
     });
     return canNarrow ? narrowedType : referenceType;
 }
-exports.narrowTypeForDiscriminatedDictEntryComparison = narrowTypeForDiscriminatedDictEntryComparison;
 function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, indexLiteralType, literalType, isPositiveTest) {
     let canNarrow = true;
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
@@ -1632,7 +1650,6 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
     });
     return canNarrow ? narrowedType : referenceType;
 }
-exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTupleComparison;
 // Attempts to narrow a type based on a comparison (equal or not equal)
 // between a discriminating field that has a declared literal type to a
 // literal value.
@@ -1672,7 +1689,6 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
     });
     return narrowedType;
 }
-exports.narrowTypeForDiscriminatedLiteralFieldComparison = narrowTypeForDiscriminatedLiteralFieldComparison;
 // Attempts to narrow a type based on a comparison (equal or not equal)
 // between a discriminating field that has a declared None type to a
 // None.
@@ -1740,9 +1756,6 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                 return subtype;
             }
         }
-        else if ((0, typeUtils_1.isNoneInstance)(subtype)) {
-            return isPositiveTest ? undefined : subtype;
-        }
         else if ((0, types_1.isAnyOrUnknown)(subtype)) {
             return isPositiveTest ? types_1.ClassType.cloneAsInstance(classType) : subtype;
         }
@@ -1755,9 +1768,6 @@ function narrowTypeForClassComparison(evaluator, referenceType, classType, isPos
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         let concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
         if (isPositiveTest) {
-            if ((0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
-                return (0, typeUtils_1.isNoneTypeClass)(classType) ? classType : undefined;
-            }
             if ((0, types_1.isClassInstance)(concreteSubtype) &&
                 types_1.TypeBase.isInstance(subtype) &&
                 types_1.ClassType.isBuiltIn(concreteSubtype, 'type')) {
@@ -1881,7 +1891,6 @@ function enumerateLiteralsForType(evaluator, type) {
     }
     return undefined;
 }
-exports.enumerateLiteralsForType = enumerateLiteralsForType;
 // Attempts to narrow a type (make it more constrained) based on a
 // call to "callable". For example, if the original type of expression "x" is
 // Union[Callable[..., Any], Type[int], int], it would remove the "int" because
@@ -1891,7 +1900,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
         var _a;
         switch (subtype.category) {
             case 4 /* TypeCategory.Function */:
-            case 5 /* TypeCategory.OverloadedFunction */: {
+            case 5 /* TypeCategory.Overloaded */: {
                 return isPositiveTest ? subtype : undefined;
             }
             case 7 /* TypeCategory.Module */: {
@@ -1964,5 +1973,4 @@ function func1(val) {
         console.log(val);
     }
 }
-exports.func1 = func1;
 //# sourceMappingURL=typeGuards.js.map