@zzzen/pyright-internal 1.2.0-dev.20240901 → 1.2.0-dev.20240915

package/dist/analyzer/typeEvaluatorTypes.d.ts

@@ -3,7 +3,7 @@ import { ConsoleInterface } from '../common/console';
 import { Diagnostic, DiagnosticAddendum } from '../common/diagnostic';
 import { DiagnosticRule } from '../common/diagnosticRules';
 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 { ArgCategory, ArgumentNode, CallNode, CaseNode, ClassNode, DecoratorNode, ExpressionNode, FunctionNode, MatchNode, NameNode, ParamCategory, ParameterNode, ParseNode, StringNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import { CodeFlowReferenceExpressionNode, FlowNode } from './codeFlowTypes';
 import { ConstraintTracker } from './constraintTracker';
@@ -13,7 +13,7 @@ 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 { ClassMember, InferenceContext, MemberAccessFlags } from './typeUtils';
 export declare const maxSubtypesForInferredType = 64;
 export declare const enum EvalFlags {
     None = 0,
@@ -45,7 +45,8 @@ export declare const enum EvalFlags {
     AllowConcatenate = 134217728,
     StripTupleLiterals = 268435456,
     IsinstanceArg = 536870912,
-    EnforceClassTypeVarScope = 1073741824,
+    TypeFormArg = 1073741824,
+    EnforceClassTypeVarScope = -2147483648,
     CallBaseDefaults = 2,
     IndexBaseDefaults = 2,
     MemberAccessBaseDefaults = 2,
@@ -162,6 +163,7 @@ export interface ExpectedTypeOptions {
     parsesStringLiteral?: boolean;
     notParsed?: boolean;
     noNonTypeSpecialForms?: boolean;
+    typeFormArg?: boolean;
     forwardRefs?: boolean;
     typeExpression?: boolean;
     convertEllipsisToAny?: boolean;
@@ -255,6 +257,28 @@ export interface CallSiteEvaluationInfo {
     errorNode: ExpressionNode;
     args: ValidateArgTypeParams[];
 }
+export interface SymbolDeclInfo {
+    decls: Declaration[];
+    synthesizedTypes: Type[];
+}
+export declare const enum AssignTypeFlags {
+    Default = 0,
+    Invariant = 1,
+    Contravariant = 2,
+    SkipRecursiveTypeCheck = 4,
+    ArgAssignmentFirstPass = 8,
+    OverloadOverlap = 16,
+    PartialOverloadOverlap = 32,
+    SkipReturnTypeCheck = 64,
+    RetainLiteralsForTypeVar = 256,
+    SkipSelfClsTypeCheck = 512,
+    PopulateExpectedType = 2048,
+    SkipPopulateUnknownExpectedType = 4096,
+    AllowUnspecifiedTypeArgs = 8192,
+    AllowIsinstanceSpecialForms = 16384,
+    SkipSelfClsParamCheck = 32768,
+    AllowProtocolClassSource = 65536
+}
 export interface TypeEvaluator {
     runWithCancellationToken<T>(token: CancellationToken, callback: () => T): T;
     getType: (node: ExpressionNode) => Type | undefined;
@@ -280,7 +304,7 @@ export interface TypeEvaluator {
     stripTypeGuard: (type: Type) => Type;
     solveAndApplyConstraints: (type: Type, constraints: ConstraintTracker, applyOptions?: ApplyTypeVarOptions, solveOptions?: SolveConstraintsOptions) => Type;
     getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
-    verifyRaiseExceptionType: (node: RaiseNode) => void;
+    verifyRaiseExceptionType: (node: ExpressionNode) => void;
     verifyDeleteExpression: (node: ExpressionNode) => void;
     validateOverloadedArgTypes: (errorNode: ExpressionNode, argList: Arg[], typeResult: TypeResult<OverloadedType>, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean, inferenceContext: InferenceContext | undefined) => CallResult;
     validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
@@ -291,8 +315,8 @@ export interface TypeEvaluator {
     isAsymmetricAccessorAssignment: (node: ParseNode) => boolean;
     suppressDiagnostics: (node: ParseNode, callback: () => void) => void;
     isSpecialFormClass: (classType: ClassType, flags: AssignTypeFlags) => boolean;
-    getDeclarationsForStringNode: (node: StringNode) => Declaration[] | undefined;
-    getDeclarationsForNameNode: (node: NameNode, skipUnreachableCode?: boolean) => Declaration[] | undefined;
+    getDeclInfoForStringNode: (node: StringNode) => SymbolDeclInfo | undefined;
+    getDeclInfoForNameNode: (node: NameNode, skipUnreachableCode?: boolean) => SymbolDeclInfo | undefined;
     getTypeForDeclaration: (declaration: Declaration) => DeclaredSymbolTypeInfo;
     resolveAliasDeclaration: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => Declaration | undefined;
     resolveAliasDeclarationWithInfo: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => DeclarationUtils.ResolvedAliasInfo | undefined;
@@ -320,6 +344,7 @@ export interface TypeEvaluator {
     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;
+    getCallbackProtocolType: (objType: ClassType, 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;
@@ -332,6 +357,8 @@ export interface TypeEvaluator {
     getBuiltInObject: (node: ParseNode, name: string, typeArgs?: Type[]) => Type;
     getTypedDictClassType: () => ClassType | undefined;
     getTupleClassType: () => ClassType | undefined;
+    getDictClassType: () => ClassType | undefined;
+    getStrClassType: () => ClassType | undefined;
     getObjectType: () => Type;
     getNoneType: () => Type;
     getUnionClassType(): Type;

package/dist/analyzer/typeEvaluatorTypes.js

@@ -8,7 +8,7 @@
  * Abstract interface and other helper types for type evaluator module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reachability = exports.EvalFlags = exports.maxSubtypesForInferredType = void 0;
+exports.AssignTypeFlags = exports.Reachability = exports.EvalFlags = exports.maxSubtypesForInferredType = void 0;
 // Maximum number of unioned subtypes for an inferred type (e.g.
 // a list) before the type is considered an "Any".
 exports.maxSubtypesForInferredType = 64;
@@ -90,9 +90,12 @@ var EvalFlags;
     // Interpret the expression using the specialized behaviors associated
     // with the second argument to isinstance and issubclass calls.
     EvalFlags[EvalFlags["IsinstanceArg"] = 536870912] = "IsinstanceArg";
+    // Interpret the expression using the behaviors associated with the first
+    // argument to a TypeForm call.
+    EvalFlags[EvalFlags["TypeFormArg"] = 1073741824] = "TypeFormArg";
     // Enforce that any type variables referenced in this type are associated
     // with the enclosing class or an outer scope.
-    EvalFlags[EvalFlags["EnforceClassTypeVarScope"] = 1073741824] = "EnforceClassTypeVarScope";
+    EvalFlags[EvalFlags["EnforceClassTypeVarScope"] = -2147483648] = "EnforceClassTypeVarScope";
     // Defaults used for evaluating the LHS of a call expression.
     EvalFlags[EvalFlags["CallBaseDefaults"] = 2] = "CallBaseDefaults";
     // Defaults used for evaluating the LHS of a member access expression.
@@ -109,4 +112,65 @@ var Reachability;
     Reachability[Reachability["UnreachableAlways"] = 1] = "UnreachableAlways";
     Reachability[Reachability["UnreachableByAnalysis"] = 2] = "UnreachableByAnalysis";
 })(Reachability || (exports.Reachability = Reachability = {}));
+var AssignTypeFlags;
+(function (AssignTypeFlags) {
+    AssignTypeFlags[AssignTypeFlags["Default"] = 0] = "Default";
+    // Require invariance with respect to class matching? Normally
+    // subclasses are allowed.
+    AssignTypeFlags[AssignTypeFlags["Invariant"] = 1] = "Invariant";
+    // The caller has swapped the source and dest types because
+    // the types are contravariant. Perform type var matching
+    // on dest type vars rather than source type var.
+    AssignTypeFlags[AssignTypeFlags["Contravariant"] = 2] = "Contravariant";
+    // We're comparing type compatibility of two distinct recursive types.
+    // This has the potential of recursing infinitely. This flag allows us
+    // to detect the recursion after the first level of checking.
+    AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 4] = "SkipRecursiveTypeCheck";
+    // During TypeVar solving for a function call, this flag is set if
+    // this is the first of multiple passes. It adjusts certain heuristics
+    // for constraint solving.
+    AssignTypeFlags[AssignTypeFlags["ArgAssignmentFirstPass"] = 8] = "ArgAssignmentFirstPass";
+    // If the dest is not Any but the src is Any, treat it
+    // as incompatible. Also, treat all source TypeVars as their
+    // concrete counterparts. This option is used for validating
+    // whether overload signatures overlap.
+    AssignTypeFlags[AssignTypeFlags["OverloadOverlap"] = 16] = "OverloadOverlap";
+    // When used in conjunction with OverloadOverlapCheck, look
+    // for partial overlaps. For example, `int | list` overlaps
+    // partially with `int | str`.
+    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlap"] = 32] = "PartialOverloadOverlap";
+    // For function types, skip the return type check.
+    AssignTypeFlags[AssignTypeFlags["SkipReturnTypeCheck"] = 64] = "SkipReturnTypeCheck";
+    // In most cases, literals are stripped when assigning to a
+    // type variable. This overrides the standard behavior.
+    AssignTypeFlags[AssignTypeFlags["RetainLiteralsForTypeVar"] = 256] = "RetainLiteralsForTypeVar";
+    // When validating the type of a self or cls parameter, allow
+    // a type mismatch. This is used in overload consistency validation
+    // because overloads can provide explicit type annotations for self
+    // or cls.
+    AssignTypeFlags[AssignTypeFlags["SkipSelfClsTypeCheck"] = 512] = "SkipSelfClsTypeCheck";
+    // We're initially populating the constraints with an expected type,
+    // so TypeVars should match the specified type exactly rather than
+    // employing narrowing or widening. The variance context determines
+    // whether the upper bound, lower bound, or both are established.
+    AssignTypeFlags[AssignTypeFlags["PopulateExpectedType"] = 2048] = "PopulateExpectedType";
+    // Used with PopulatingExpectedType, this flag indicates that a TypeVar
+    // constraint that is Unknown should be ignored.
+    AssignTypeFlags[AssignTypeFlags["SkipPopulateUnknownExpectedType"] = 4096] = "SkipPopulateUnknownExpectedType";
+    // Normally, when a class type is assigned to a TypeVar and that class
+    // hasn't previously been specialized, it will be specialized with
+    // default type arguments (typically "Unknown"). This flag skips
+    // this step.
+    AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArgs"] = 8192] = "AllowUnspecifiedTypeArgs";
+    // Normally all special form classes are incompatible with type[T],
+    // but a few of them are allowed in the context of an isinstance
+    // or issubclass call.
+    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 16384] = "AllowIsinstanceSpecialForms";
+    // When comparing two methods, skip the type check for the "self" or "cls"
+    // parameters. This is used for variance inference and validation.
+    AssignTypeFlags[AssignTypeFlags["SkipSelfClsParamCheck"] = 32768] = "SkipSelfClsParamCheck";
+    // Normally a protocol class object cannot be used as a source type. This
+    // option overrides this behavior.
+    AssignTypeFlags[AssignTypeFlags["AllowProtocolClassSource"] = 65536] = "AllowProtocolClassSource";
+})(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 //# sourceMappingURL=typeEvaluatorTypes.js.map

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

package/dist/analyzer/typeGuards.d.ts

@@ -1,26 +1,17 @@
 import { ExpressionNode } from '../parser/parseNodes';
 import { TypeEvaluator } from './typeEvaluatorTypes';
-import { ClassType, Type } from './types';
+import { AnyType, ClassType, FunctionType, OverloadedType, Type, TypeVarType, UnknownType } from './types';
 export interface TypeNarrowingResult {
     type: Type;
     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 isIsinstanceFilterSuperclass(evaluator: TypeEvaluator, varType: Type, concreteVarType: ClassType, filterType: Type, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
-export declare function isIsinstanceFilterSubclass(evaluator: TypeEvaluator, varType: ClassType, concreteFilterType: ClassType, isInstanceCheck: boolean): boolean;
+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 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;
 export declare function narrowTypeForDiscriminatedTupleComparison(evaluator: TypeEvaluator, referenceType: Type, indexLiteralType: ClassType, literalType: Type, isPositiveTest: boolean): Type;
 export declare function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator: TypeEvaluator, referenceType: Type, memberName: string, literalType: ClassType, isPositiveTest: boolean): Type;
 export declare function enumerateLiteralsForType(evaluator: TypeEvaluator, type: ClassType): ClassType[] | undefined;
-export declare class Animal {
-}
-export declare class Dog extends Animal {
-}
-export declare class Plant {
-}
-export declare class Tree extends Plant {
-}
-export declare function func1(val: Animal): void;