@zzzen/pyright-internal 1.2.0-dev.20230101 → 1.2.0-dev.20230115

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -20,23 +20,23 @@ export declare const enum EvaluatorFlags {
     DoNotSpecialize = 2,
     AllowForwardReferences = 4,
     EvaluateStringLiteralAsType = 8,
-    FinalDisallowed = 16,
-    ParamSpecDisallowed = 32,
-    ExpectingType = 64,
-    TypeVarTupleDisallowed = 128,
-    ConvertEllipsisToUnknown = 256,
-    AllowGenericClassType = 512,
-    ExpectingTypeAnnotation = 1024,
+    DisallowFinal = 16,
+    DisallowParamSpec = 32,
+    DisallowTypeVarTuple = 64,
+    ExpectingType = 128,
+    ExpectingTypeAnnotation = 256,
+    ConvertEllipsisToUnknown = 512,
+    AllowGenericClassType = 1024,
     DisallowTypeVarsWithScopeId = 2048,
     DisallowTypeVarsWithoutScopeId = 4096,
     AssociateTypeVarsWithCurrentScope = 8192,
     EnforceTypeVarVarianceConsistency = 16384,
     VariableTypeAnnotation = 32768,
     DisallowRecursiveTypeAliasPlaceholder = 65536,
-    ClassVarDisallowed = 131072,
+    DisallowClassVar = 131072,
     DisallowNakedGeneric = 262144,
     NotParsedByInterpreter = 524288,
-    RequiredAllowed = 1048576,
+    AllowRequired = 1048576,
     AllowUnpackedTupleOrTypeVarTuple = 2097152,
     InterpreterParsesStringLiteral = 4194304,
     AllowUnpackedTypedDict = 8388608
@@ -54,6 +54,7 @@ export interface TypeResult {
     isAsymmetricDescriptor?: boolean;
     isRequired?: boolean;
     isNotRequired?: boolean;
+    overloadsUsedForCall?: FunctionType[];
 }
 export interface TypeResultWithNode extends TypeResult {
     node: ParseNode;
@@ -147,6 +148,10 @@ export interface FunctionResult {
     argumentErrors: boolean;
     isTypeIncomplete: boolean;
 }
+export interface InferenceContext {
+    expectedType: Type;
+    typeVarContext?: TypeVarContext;
+}
 export interface CallResult {
     returnType?: Type | undefined;
     isTypeIncomplete?: boolean | undefined;
@@ -154,6 +159,7 @@ export interface CallResult {
     isArgumentAnyOrUnknown?: boolean;
     activeParam?: FunctionParameter | undefined;
     specializedInitSelfType?: Type | undefined;
+    overloadsUsedForCall: FunctionType[];
 }
 export interface PrintTypeOptions {
     expandTypeAlias?: boolean;
@@ -163,8 +169,9 @@ export interface PrintTypeOptions {
 export interface TypeEvaluator {
     runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
     getType: (node: ExpressionNode) => Type | undefined;
+    getTypeResult: (node: ExpressionNode) => TypeResult | undefined;
     getCachedType: (node: ExpressionNode) => Type | undefined;
-    getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, expectedType?: Type) => TypeResult;
+    getTypeOfExpression: (node: ExpressionNode, flags?: EvaluatorFlags, context?: InferenceContext) => TypeResult;
     getTypeOfAnnotation: (node: ExpressionNode, options?: AnnotationTypeOptions) => Type;
     getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
     getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
@@ -182,7 +189,7 @@ export interface TypeEvaluator {
     getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
     verifyRaiseExceptionType: (node: RaiseNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
-    validateOverloadedFunctionArguments: (errorNode: ExpressionNode, argList: FunctionArgument[], type: OverloadedFunctionType, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean, expectedType: Type | undefined) => CallResult;
+    validateOverloadedFunctionArguments: (errorNode: ExpressionNode, argList: FunctionArgument[], type: OverloadedFunctionType, typeVarContext: TypeVarContext | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
     isAfterNodeReachable: (node: ParseNode) => boolean;
     isNodeReachable: (node: ParseNode, sourceNode: ParseNode | undefined) => boolean;
     isAsymmetricDescriptorAssignment: (node: ParseNode) => boolean;
@@ -213,7 +220,7 @@ export interface TypeEvaluator {
     getTypeOfMember: (member: ClassMember) => Type;
     getTypeOfObjectMember(errorNode: ExpressionNode, objectType: ClassType, memberName: string): TypeResult | undefined;
     getBoundMethod: (classType: ClassType, memberName: string, recursionCount?: number, treatConstructorAsClassMember?: boolean) => FunctionType | OverloadedFunctionType | undefined;
-    getTypeOfMagicMethodReturn: (objType: Type, args: TypeResult[], magicMethodName: string, errorNode: ExpressionNode, expectedType: Type | undefined) => Type | undefined;
+    getTypeOfMagicMethodReturn: (objType: Type, args: TypeResult[], magicMethodName: string, errorNode: ExpressionNode, inferenceContext: InferenceContext | undefined) => Type | undefined;
     bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedFunctionType, memberClass?: ClassType, errorNode?: ParseNode, recursionCount?: number, treatConstructorAsClassMember?: boolean, firstParamType?: ClassType | TypeVarType) => FunctionType | OverloadedFunctionType | undefined;
     getCallSignatureInfo: (node: CallNode, activeIndex: number, activeOrFake: boolean) => CallSignatureInfo | undefined;
     getAbstractMethods: (classType: ClassType) => AbstractMethod[];
@@ -237,7 +244,7 @@ export interface TypeEvaluator {
     addUnusedCode: (node: ParseNode, textRange: TextRange) => void;
     addUnreachableCode: (node: ParseNode, textRange: TextRange) => void;
     addDeprecated: (message: string, node: ParseNode) => void;
-    addDiagnostic: (diagLevel: DiagnosticLevel, rule: string, message: string, node: ParseNode) => Diagnostic | undefined;
+    addDiagnostic: (diagLevel: DiagnosticLevel, rule: string, message: string, node: ParseNode, range?: TextRange) => Diagnostic | undefined;
     addDiagnosticForTextRange: (fileInfo: AnalyzerFileInfo, diagLevel: DiagnosticLevel, rule: string, message: string, range: TextRange) => Diagnostic | undefined;
     printType: (type: Type, options?: PrintTypeOptions) => string;
     printFunctionParts: (type: FunctionType) => [string[], string];

package/dist/analyzer/typeEvaluatorTypes.js

@@ -27,28 +27,28 @@ var EvaluatorFlags;
     // Treat string literal as a type.
     EvaluatorFlags[EvaluatorFlags["EvaluateStringLiteralAsType"] = 8] = "EvaluateStringLiteralAsType";
     // 'Final' is not allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["FinalDisallowed"] = 16] = "FinalDisallowed";
+    EvaluatorFlags[EvaluatorFlags["DisallowFinal"] = 16] = "DisallowFinal";
     // A ParamSpec isn't allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["ParamSpecDisallowed"] = 32] = "ParamSpecDisallowed";
+    EvaluatorFlags[EvaluatorFlags["DisallowParamSpec"] = 32] = "DisallowParamSpec";
+    // A TypeVarTuple isn't allowed in this context.
+    EvaluatorFlags[EvaluatorFlags["DisallowTypeVarTuple"] = 64] = "DisallowTypeVarTuple";
     // Expression is expected to be a type (class) rather
     // than an instance (object)
-    EvaluatorFlags[EvaluatorFlags["ExpectingType"] = 64] = "ExpectingType";
-    // A TypeVarTuple isn't allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["TypeVarTupleDisallowed"] = 128] = "TypeVarTupleDisallowed";
-    // Interpret an ellipsis type annotation to mean "Unknown".
-    EvaluatorFlags[EvaluatorFlags["ConvertEllipsisToUnknown"] = 256] = "ConvertEllipsisToUnknown";
-    // The Generic class type is allowed in this context. It is
-    // normally not allowed if ExpectingType is set.
-    EvaluatorFlags[EvaluatorFlags["AllowGenericClassType"] = 512] = "AllowGenericClassType";
+    EvaluatorFlags[EvaluatorFlags["ExpectingType"] = 128] = "ExpectingType";
     // A type annotation restricts the types of expressions that are
     // allowed. If this flag is set, illegal type expressions are
     // flagged as errors.
-    EvaluatorFlags[EvaluatorFlags["ExpectingTypeAnnotation"] = 1024] = "ExpectingTypeAnnotation";
+    EvaluatorFlags[EvaluatorFlags["ExpectingTypeAnnotation"] = 256] = "ExpectingTypeAnnotation";
+    // Interpret an ellipsis type annotation to mean "Unknown".
+    EvaluatorFlags[EvaluatorFlags["ConvertEllipsisToUnknown"] = 512] = "ConvertEllipsisToUnknown";
+    // The Generic class type is allowed in this context. It is
+    // normally not allowed if ExpectingType is set.
+    EvaluatorFlags[EvaluatorFlags["AllowGenericClassType"] = 1024] = "AllowGenericClassType";
     // TypeVars within this expression must not refer to type vars
-    // used in an outer scope that.
+    // used in an outer scope.
     EvaluatorFlags[EvaluatorFlags["DisallowTypeVarsWithScopeId"] = 2048] = "DisallowTypeVarsWithScopeId";
     // TypeVars within this expression must refer to type vars
-    // used in an outer scope that.
+    // used in an outer scope.
     EvaluatorFlags[EvaluatorFlags["DisallowTypeVarsWithoutScopeId"] = 4096] = "DisallowTypeVarsWithoutScopeId";
     // TypeVars within this expression that are otherwise not
     // associated with an outer scope should be associated with
@@ -64,14 +64,14 @@ var EvaluatorFlags;
     // used in this context.
     EvaluatorFlags[EvaluatorFlags["DisallowRecursiveTypeAliasPlaceholder"] = 65536] = "DisallowRecursiveTypeAliasPlaceholder";
     // 'ClassVar' is not allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["ClassVarDisallowed"] = 131072] = "ClassVarDisallowed";
+    EvaluatorFlags[EvaluatorFlags["DisallowClassVar"] = 131072] = "DisallowClassVar";
     // 'Generic' cannot be used without type arguments in this context.
     EvaluatorFlags[EvaluatorFlags["DisallowNakedGeneric"] = 262144] = "DisallowNakedGeneric";
     // The node is not parsed by the interpreter because it is within
     // a comment or a string literal.
     EvaluatorFlags[EvaluatorFlags["NotParsedByInterpreter"] = 524288] = "NotParsedByInterpreter";
     // Required and NotRequired are allowed in this context.
-    EvaluatorFlags[EvaluatorFlags["RequiredAllowed"] = 1048576] = "RequiredAllowed";
+    EvaluatorFlags[EvaluatorFlags["AllowRequired"] = 1048576] = "AllowRequired";
     // Allow Unpack annotation for a tuple or TypeVarTuple.
     EvaluatorFlags[EvaluatorFlags["AllowUnpackedTupleOrTypeVarTuple"] = 2097152] = "AllowUnpackedTupleOrTypeVarTuple";
     // Even though an expression is enclosed in a string literal,

package/dist/analyzer/typeEvaluatorTypes.js.map

@@ -1 +1 @@
-{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA2CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cA0FjB;AA1FD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,0EAAwB,CAAA;IAExB,6CAA6C;IAC7C,kFAA4B,CAAA;IAE5B,qDAAqD;IACrD,4BAA4B;IAC5B,sEAAsB,CAAA;IAEtB,gDAAgD;IAChD,yFAA+B,CAAA;IAE/B,2DAA2D;IAC3D,6FAAiC,CAAA;IAEjC,2DAA2D;IAC3D,gDAAgD;IAChD,uFAA8B,CAAA;IAE9B,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,4FAAiC,CAAA;IAEjC,8DAA8D;IAC9D,+BAA+B;IAC/B,oGAAqC,CAAA;IAErC,0DAA0D;IAC1D,+BAA+B;IAC/B,0GAAwC,CAAA;IAExC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,yDAAyD;IACzD,wBAAwB;IACxB,yHAA+C,CAAA;IAE/C,6CAA6C;IAC7C,oFAA4B,CAAA;IAE5B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,+EAAyB,CAAA;IAEzB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;AACpC,CAAC,EA1FiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QA0F/B"}
+{"version":3,"file":"typeEvaluatorTypes.js","sourceRoot":"","sources":["../../../src/analyzer/typeEvaluatorTypes.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA2CH,gEAAgE;AAChE,kDAAkD;AACrC,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C,IAAkB,cA0FjB;AA1FD,WAAkB,cAAc;IAC5B,mDAAQ,CAAA;IAER,uDAAuD;IACvD,mFAA6B,CAAA;IAE7B,0DAA0D;IAC1D,gEAAgE;IAChE,SAAS;IACT,yEAAwB,CAAA;IAExB,yDAAyD;IACzD,uFAA+B,CAAA;IAE/B,kCAAkC;IAClC,iGAAoC,CAAA;IAEpC,0CAA0C;IAC1C,sEAAsB,CAAA;IAEtB,6CAA6C;IAC7C,8EAA0B,CAAA;IAE1B,gDAAgD;IAChD,oFAA6B,CAAA;IAE7B,qDAAqD;IACrD,4BAA4B;IAC5B,uEAAsB,CAAA;IAEtB,gEAAgE;IAChE,6DAA6D;IAC7D,qBAAqB;IACrB,2FAAgC,CAAA;IAEhC,2DAA2D;IAC3D,6FAAiC,CAAA;IAEjC,2DAA2D;IAC3D,gDAAgD;IAChD,wFAA+B,CAAA;IAE/B,8DAA8D;IAC9D,0BAA0B;IAC1B,oGAAqC,CAAA;IAErC,0DAA0D;IAC1D,0BAA0B;IAC1B,0GAAwC,CAAA;IAExC,yDAAyD;IACzD,2DAA2D;IAC3D,mCAAmC;IACnC,gHAA2C,CAAA;IAE3C,yDAAyD;IACzD,6DAA6D;IAC7D,uDAAuD;IACvD,iHAA2C,CAAA;IAE3C,mDAAmD;IACnD,2FAAgC,CAAA;IAEhC,yDAAyD;IACzD,wBAAwB;IACxB,yHAA+C,CAAA;IAE/C,6CAA6C;IAC7C,gFAA0B,CAAA;IAE1B,mEAAmE;IACnE,wFAA8B,CAAA;IAE9B,iEAAiE;IACjE,iCAAiC;IACjC,4FAAgC,CAAA;IAEhC,wDAAwD;IACxD,2EAAuB,CAAA;IAEvB,uDAAuD;IACvD,iHAA0C,CAAA;IAE1C,6DAA6D;IAC7D,2DAA2D;IAC3D,oDAAoD;IACpD,6GAAwC,CAAA;IAExC,yCAAyC;IACzC,6FAAgC,CAAA;AACpC,CAAC,EA1FiB,cAAc,GAAd,sBAAc,KAAd,sBAAc,QA0F/B"}

package/dist/analyzer/typeGuards.d.ts

@@ -1,7 +1,11 @@
 import { ExpressionNode } from '../parser/parseNodes';
 import { TypeEvaluator } from './typeEvaluatorTypes';
 import { ClassType, Type } from './types';
-export declare type TypeNarrowingCallback = (type: Type) => Type | undefined;
+export interface TypeNarrowingResult {
+    type: Type;
+    isIncomplete: boolean;
+}
+export declare 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 isIsinstanceFilterSuperclass(evaluator: TypeEvaluator, varType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
 export declare function isIsinstanceFilterSubclass(evaluator: TypeEvaluator, varType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;