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

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -12,7 +12,7 @@ import * as DeclarationUtils from './declarationUtils';
 import { SymbolWithScope } from './scope';
 import { Symbol } from './symbol';
 import { PrintTypeFlags } from './typePrinter';
-import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedFunctionType, Type, TypeCondition, TypeVarScopeId, TypeVarType, UnknownType, Variance } from './types';
+import { AnyType, ClassType, FunctionParam, FunctionType, OverloadedType, Type, TypeCondition, TypeVarScopeId, TypeVarType, UnknownType, Variance } from './types';
 import { AssignTypeFlags, ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
 export declare const maxSubtypesForInferredType = 64;
 export declare const enum EvalFlags {
@@ -180,7 +180,6 @@ export interface ArgResult {
     argType: Type;
     isTypeIncomplete?: boolean | undefined;
     condition?: TypeCondition[];
-    skippedOverloadArg?: boolean;
     skippedBareTypeVarExpectedType?: boolean;
 }
 export interface CallResult {
@@ -206,7 +205,6 @@ export interface ClassMemberLookup {
     memberAccessDeprecationInfo?: MemberAccessDeprecationInfo;
 }
 export interface SolveConstraintsOptions {
-    applyUnificationVars?: boolean;
     useLowerBoundOnly?: boolean;
 }
 export interface ApplyTypeVarOptions {
@@ -284,7 +282,7 @@ export interface TypeEvaluator {
     getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
     verifyRaiseExceptionType: (node: RaiseNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
-    validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedFunctionType>, constraints: ConstraintTracker | 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;
@@ -315,18 +313,18 @@ 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;
+    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 | OverloadedFunctionType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedFunctionType | 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, destConstraints?: ConstraintTracker, srcConstraints?: ConstraintTracker, flags?: AssignTypeFlags, recursionCount?: number) => boolean;
-    validateOverrideMethod: (baseMethod: Type, overrideMethod: FunctionType | OverloadedFunctionType, baseClass: ClassType | undefined, diag: DiagnosticAddendum, enforceParamNames?: boolean) => boolean;
+    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;
@@ -341,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, destConstraints: ConstraintTracker | undefined, srcConstraints: ConstraintTracker | 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;

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"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;AAuRD,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,7 +33,17 @@ 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");
@@ -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 */ ||
@@ -861,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;
@@ -877,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, 
@@ -899,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.
@@ -957,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, 
-                        /* destConstraints */ undefined, 
-                        /* srcConstraints */ undefined, 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;
@@ -1084,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, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
+                    /* constraints */ undefined, 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */)) {
                         if (isPositiveTest) {
                             filteredTypes.push(filterType);
                         }
@@ -1125,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
@@ -1175,7 +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))) {
+                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)) {
@@ -1194,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);
         }
@@ -1256,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) {
@@ -1476,7 +1490,6 @@ function getElementTypeForContainerNarrowing(containerType) {
     }
     return elementType;
 }
-exports.getElementTypeForContainerNarrowing = getElementTypeForContainerNarrowing;
 function narrowTypeForContainerElementType(evaluator, referenceType, elementType) {
     let canNarrow = true;
     const elementTypeWithoutLiteral = evaluator.stripLiteralValue(elementType);
@@ -1535,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) {
@@ -1611,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) => {
@@ -1639,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.
@@ -1679,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.
@@ -1747,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;
         }
@@ -1762,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')) {
@@ -1888,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
@@ -1898,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 */: {
@@ -1971,5 +1973,4 @@ function func1(val) {
         console.log(val);
     }
 }
-exports.func1 = func1;
 //# sourceMappingURL=typeGuards.js.map