@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/analyzer/types.d.ts

@@ -1,5 +1,5 @@
 import { Uri } from '../common/uri/uri';
-import { ArgumentNode, ExpressionNode, NameNode, ParameterCategory } from '../parser/parseNodes';
+import { ArgumentNode, NameNode, ParameterCategory } from '../parser/parseNodes';
 import { ClassDeclaration, FunctionDeclaration, SpecialBuiltInClassDeclaration } from './declaration';
 import { Symbol, SymbolTable } from './symbol';
 export declare const enum TypeCategory {
@@ -17,7 +17,9 @@ export declare const enum TypeCategory {
 export declare const enum TypeFlags {
     None = 0,
     Instantiable = 1,
-    Instance = 2
+    Instance = 2,
+    Ambiguous = 4,
+    TypeCompatibilityMask = 3
 }
 export type UnionableType = UnboundType | UnknownType | AnyType | FunctionType | OverloadedFunctionType | ClassType | ModuleType | TypeVarType;
 export type Type = UnionableType | NeverType | UnionType;
@@ -49,64 +51,77 @@ export interface TypeAliasInfo {
     fileUri: Uri;
     typeVarScopeId: TypeVarScopeId;
     isPep695Syntax: boolean;
-    typeParameters?: TypeVarType[] | undefined;
-    usageVariance?: Variance[];
-    typeArguments?: Type[] | undefined;
-}
-interface TypeBase {
-    category: TypeCategory;
+    typeParameters: TypeVarType[] | undefined;
+    usageVariance: Variance[] | undefined;
+    typeArguments: Type[] | undefined;
+}
+interface CachedTypeInfo {
+    instantiableType?: Type;
+    instanceType?: Type;
+    typeBaseInstantiableType?: Type;
+    typeBaseInstanceType?: Type;
+    requiresSpecialization?: boolean;
+}
+interface TypeBaseProps {
+    instantiableDepth: number | undefined;
+    specialForm: ClassType | undefined;
+    typeAliasInfo: TypeAliasInfo | undefined;
+    condition: TypeCondition[] | undefined;
+}
+interface TypeBase<T extends TypeCategory> {
+    category: T;
     flags: TypeFlags;
-    instantiableNestingLevel?: number;
-    specialForm?: ClassType;
-    typeAliasInfo?: TypeAliasInfo | undefined;
-    condition?: TypeCondition[] | undefined;
-    isAmbiguous?: boolean;
-    cached?: {
-        instantiableType?: Type;
-        instanceType?: Type;
-        typeBaseInstantiableType?: Type;
-        typeBaseInstanceType?: Type;
-        requiresSpecialization?: boolean;
-    };
+    props: TypeBaseProps | undefined;
+    cached: CachedTypeInfo | undefined;
+    shared: object | undefined;
+    priv: object | undefined;
 }
 export declare namespace TypeBase {
-    function isInstantiable(type: TypeBase): boolean;
-    function isInstance(type: TypeBase): boolean;
-    function isAmbiguous(type: TypeBase): boolean;
-    function cloneType<T extends TypeBase>(type: T): T;
-    function cloneAsSpecialForm<T extends TypeBase>(type: T, specialForm: ClassType | undefined): T;
+    function isInstantiable(type: TypeBase<any>): boolean;
+    function isInstance(type: TypeBase<any>): boolean;
+    function isAmbiguous(type: TypeBase<any>): boolean;
+    function addProps(type: TypeBase<any>): TypeBaseProps;
+    function setSpecialForm(type: TypeBase<any>, specialForm: ClassType | undefined): void;
+    function setInstantiableDepth(type: TypeBase<any>, depth: number | undefined): void;
+    function setTypeAliasInfo(type: TypeBase<any>, typeAliasInfo: TypeAliasInfo | undefined): void;
+    function setCondition(type: TypeBase<any>, condition: TypeCondition[] | undefined): void;
+    function cloneType<T extends TypeBase<any>>(type: T): T;
+    function cloneAsSpecialForm<T extends TypeBase<any>>(type: T, specialForm: ClassType | undefined): T;
     function cloneTypeAsInstance<T extends Type>(type: T, cache: boolean): T;
     function cloneTypeAsInstantiable<T extends Type>(type: T, cache: boolean): T;
     function cloneForTypeAlias(type: Type, name: string, fullName: string, moduleName: string, fileUri: Uri, typeVarScopeId: TypeVarScopeId, isPep695Syntax: boolean, typeParams?: TypeVarType[], typeArgs?: Type[]): Type;
     function cloneForCondition<T extends Type>(type: T, condition: TypeCondition[] | undefined): T;
     function cloneForAmbiguousType(type: Type): Type;
 }
-export interface UnboundType extends TypeBase {
-    category: TypeCategory.Unbound;
+export interface UnboundType extends TypeBase<TypeCategory.Unbound> {
 }
 export declare namespace UnboundType {
     function create(): UnboundType;
     function convertToInstance(type: UnboundType): UnboundType;
 }
-export interface UnknownType extends TypeBase {
-    category: TypeCategory.Unknown;
+export interface UnknownTypeDetailsPriv {
     isIncomplete: boolean;
-    possibleType?: Type;
+    possibleType: Type | undefined;
+}
+export interface UnknownType extends TypeBase<TypeCategory.Unknown> {
+    priv: UnknownTypeDetailsPriv;
 }
 export declare namespace UnknownType {
     function create(isIncomplete?: boolean): UnknownType;
     function createPossibleType(possibleType: Type, isIncomplete: boolean): UnknownType;
     function convertToInstance(type: UnknownType): UnknownType;
 }
-export interface ModuleType extends TypeBase {
-    category: TypeCategory.Module;
+export interface ModuleTypeDetailsPriv {
     fields: SymbolTable;
-    docString?: string | undefined;
-    notPresentFieldType?: AnyType | UnknownType;
+    docString: string | undefined;
+    notPresentFieldType: AnyType | UnknownType | undefined;
     loaderFields: SymbolTable;
     moduleName: string;
     fileUri: Uri;
 }
+export interface ModuleType extends TypeBase<TypeCategory.Module> {
+    priv: ModuleTypeDetailsPriv;
+}
 export declare namespace ModuleType {
     function create(moduleName: string, fileUri: Uri, symbolTable?: SymbolTable): ModuleType;
     function getField(moduleType: ModuleType, name: string): Symbol | undefined;
@@ -119,7 +134,6 @@ export interface DataClassEntry {
     alias?: string | undefined;
     hasDefault?: boolean | undefined;
     nameNode: NameNode | undefined;
-    defaultValueExpression?: ExpressionNode | undefined;
     includeInInit: boolean;
     type: Type;
     converter?: ArgumentNode | undefined;
@@ -136,7 +150,7 @@ export interface TypedDictEntries {
 }
 export declare const enum ClassTypeFlags {
     None = 0,
-    BuiltInClass = 1,
+    BuiltIn = 1,
     SpecialBuiltIn = 2,
     TypedDictClass = 4,
     TypedDictMarkedClosed = 8,
@@ -159,7 +173,8 @@ export declare const enum ClassTypeFlags {
     TypeCheckOnly = 1048576,
     NewTypeClass = 2097152,
     ValidTypeAliasClass = 4194304,
-    SpecialFormClass = 8388608
+    SpecialFormClass = 8388608,
+    IllegalIsinstanceClass = 16777216
 }
 export interface DataClassBehaviors {
     skipGenerateInit?: boolean;
@@ -172,7 +187,7 @@ export interface DataClassBehaviors {
     frozenDefault?: boolean;
     fieldDescriptorNames: string[];
 }
-interface ClassDetails {
+interface ClassDetailsShared {
     name: string;
     fullName: string;
     moduleName: string;
@@ -210,9 +225,7 @@ export interface PropertyMethodInfo {
     methodType: FunctionType;
     classType: ClassType | undefined;
 }
-export interface ClassType extends TypeBase {
-    category: TypeCategory.Class;
-    details: ClassDetails;
+export interface ClassDetailsPriv {
     typeArguments?: Type[] | undefined;
     typeGuardType?: Type | undefined;
     isStrictTypeGuard?: boolean;
@@ -233,6 +246,10 @@ export interface ClassType extends TypeBase {
     fdelInfo?: PropertyMethodInfo | undefined;
     deprecatedInstanceMessage?: string | undefined;
 }
+export interface ClassType extends TypeBase<TypeCategory.Class> {
+    shared: ClassDetailsShared;
+    priv: ClassDetailsPriv;
+}
 export declare namespace ClassType {
     function createInstantiable(name: string, fullName: string, moduleName: string, fileUri: Uri, flags: ClassTypeFlags, typeSourceId: TypeSourceId, declaredMetaclass: ClassType | UnknownType | undefined, effectiveMetaclass: ClassType | UnknownType | undefined, docString?: string): ClassType;
     function cloneAsInstance(type: ClassType, includeSubclasses?: boolean): ClassType;
@@ -268,6 +285,7 @@ export declare namespace ClassType {
     function isNewTypeClass(classType: ClassType): boolean;
     function isValidTypeAliasClass(classType: ClassType): boolean;
     function isSpecialFormClass(classType: ClassType): boolean;
+    function isIllegalIsinstanceClass(classType: ClassType): boolean;
     function isTypedDictClass(classType: ClassType): boolean;
     function isCanOmitDictValues(classType: ClassType): boolean;
     function isTypedDictMarkedClosed(classType: ClassType): boolean;
@@ -295,20 +313,27 @@ export declare namespace ClassType {
     function isDerivedFrom(subclassType: ClassType, parentClassType: ClassType, inheritanceChain?: InheritanceChain): boolean;
     function getReverseMro(classType: ClassType): (ClassType | UnknownType | AnyType)[];
 }
-export interface FunctionParameter {
+export declare enum FunctionParamFlags {
+    None = 0,
+    NameSynthesized = 1,
+    TypeDeclared = 2,
+    TypeInferred = 4
+}
+export interface FunctionParam {
     category: ParameterCategory;
-    name?: string | undefined;
-    isNameSynthesized?: boolean;
-    hasDefault?: boolean | undefined;
-    defaultValueExpression?: ExpressionNode | undefined;
     type: Type;
-    isTypeInferred?: boolean | undefined;
-    defaultType?: Type | undefined;
-    hasDeclaredType?: boolean | undefined;
-    typeAnnotation?: ExpressionNode | undefined;
-}
-export declare function isPositionOnlySeparator(param: FunctionParameter): boolean;
-export declare function isKeywordOnlySeparator(param: FunctionParameter): boolean;
+    flags: FunctionParamFlags;
+    name: string | undefined;
+    defaultType: Type | undefined;
+}
+export declare namespace FunctionParam {
+    function create(category: ParameterCategory, type: Type, flags?: FunctionParamFlags, name?: string, defaultType?: Type): FunctionParam;
+    function isNameSynthesized(param: FunctionParam): boolean;
+    function isTypeDeclared(param: FunctionParam): boolean;
+    function isTypeInferred(param: FunctionParam): boolean;
+}
+export declare function isPositionOnlySeparator(param: FunctionParam): boolean;
+export declare function isKeywordOnlySeparator(param: FunctionParam): boolean;
 export declare const enum FunctionTypeFlags {
     None = 0,
     ConstructorMethod = 1,
@@ -329,30 +354,28 @@ export declare const enum FunctionTypeFlags {
     ParamSpecValue = 65536,
     PartiallyEvaluated = 131072,
     Overridden = 262144,
-    NoTypeCheck = 524288
+    NoTypeCheck = 524288,
+    BuiltIn = 1048576
 }
-interface FunctionDetails {
+interface FunctionDetailsShared {
     name: string;
     fullName: string;
     moduleName: string;
     flags: FunctionTypeFlags;
     typeParameters: TypeVarType[];
-    parameters: FunctionParameter[];
-    declaredReturnType?: Type | undefined;
-    declaration?: FunctionDeclaration | undefined;
-    typeVarScopeId?: TypeVarScopeId | undefined;
-    builtInName?: string | undefined;
-    docString?: string | undefined;
-    deprecatedMessage?: string | undefined;
-    methodClass?: ClassType | undefined;
-    decoratorDataClassBehaviors?: DataClassBehaviors | undefined;
-    constructorTypeVarScopeId?: TypeVarScopeId | undefined;
-    higherOrderTypeVarScopeIds?: TypeVarScopeId[];
+    parameters: FunctionParam[];
+    declaredReturnType: Type | undefined;
+    declaration: FunctionDeclaration | undefined;
+    typeVarScopeId: TypeVarScopeId | undefined;
+    docString: string | undefined;
+    deprecatedMessage: string | undefined;
+    methodClass: ClassType | undefined;
+    decoratorDataClassBehaviors: DataClassBehaviors | undefined;
 }
 export interface SpecializedFunctionTypes {
     parameterTypes: Type[];
-    parameterDefaultArgs?: (Type | undefined)[];
-    returnType?: Type | undefined;
+    parameterDefaultArgs: (Type | undefined)[] | undefined;
+    returnType: Type | undefined;
 }
 export interface CallSiteInferenceTypeCacheEntry {
     paramTypes: Type[];
@@ -362,20 +385,23 @@ export interface SignatureWithOffsets {
     type: FunctionType | OverloadedFunctionType;
     expressionOffsets: number[];
 }
-export interface FunctionType extends TypeBase {
-    category: TypeCategory.Function;
-    details: FunctionDetails;
+export interface FunctionDetailsPriv {
+    constructorTypeVarScopeId?: TypeVarScopeId | undefined;
+    higherOrderTypeVarScopeIds?: TypeVarScopeId[];
     specializedTypes?: SpecializedFunctionTypes | undefined;
     inferredReturnType?: Type | undefined;
     callSiteReturnTypeCache?: CallSiteInferenceTypeCacheEntry[];
     strippedFirstParamType?: Type | undefined;
     boundToType?: ClassType | undefined;
     preBoundFlags?: FunctionTypeFlags;
-    boundTypeVarScopeId?: TypeVarScopeId | undefined;
     overloaded?: OverloadedFunctionType;
     trackedSignatures?: SignatureWithOffsets[];
     isCallableWithTypeArgs?: boolean;
 }
+export interface FunctionType extends TypeBase<TypeCategory.Function> {
+    shared: FunctionDetailsShared;
+    priv: FunctionDetailsPriv;
+}
 export declare namespace FunctionType {
     function createInstance(name: string, fullName: string, moduleName: string, functionFlags: FunctionTypeFlags, docString?: string): FunctionType;
     function createInstantiable(functionFlags: FunctionTypeFlags, docString?: string): FunctionType;
@@ -386,7 +412,7 @@ export declare namespace FunctionType {
     function cloneForSpecialization(type: FunctionType, specializedTypes: SpecializedFunctionTypes, specializedInferredReturnType: Type | undefined): FunctionType;
     function applyParamSpecValue(type: FunctionType, paramSpecValue: FunctionType): FunctionType;
     function cloneWithNewFlags(type: FunctionType, flags: FunctionTypeFlags): FunctionType;
-    function cloneWithNewTypeVarScopeId(type: FunctionType, newScopeId: TypeVarScopeId, typeParameters: TypeVarType[], trackedSignatures?: SignatureWithOffsets[]): FunctionType;
+    function cloneWithNewTypeVarScopeId(type: FunctionType, newScopeId: TypeVarScopeId, newConstructorScopeId: TypeVarScopeId | undefined, typeParameters: TypeVarType[], trackedSignatures?: SignatureWithOffsets[]): FunctionType;
     function cloneWithDocString(type: FunctionType, docString?: string): FunctionType;
     function cloneWithDeprecatedMessage(type: FunctionType, deprecatedMessage?: string): FunctionType;
     function cloneRemoveParamSpecArgsKwargs(type: FunctionType, stripPositionOnlySeparator?: boolean): FunctionType;
@@ -394,7 +420,7 @@ export declare namespace FunctionType {
     function addParamSpecVariadics(type: FunctionType, paramSpec: TypeVarType): void;
     function addDefaultParameters(type: FunctionType, useUnknown?: boolean): void;
     function addHigherOrderTypeVarScopeIds(functionType: FunctionType, scopeIds: (TypeVarScopeId | undefined)[] | TypeVarScopeId | undefined): void;
-    function getDefaultParameters(useUnknown?: boolean): FunctionParameter[];
+    function getDefaultParameters(useUnknown?: boolean): FunctionParam[];
     function hasDefaultParameters(functionType: FunctionType): boolean;
     function isInstanceMethod(type: FunctionType): boolean;
     function isConstructorMethod(type: FunctionType): boolean;
@@ -415,36 +441,43 @@ export declare namespace FunctionType {
     function isParamSpecValue(type: FunctionType): boolean;
     function isPartiallyEvaluated(type: FunctionType): boolean;
     function isOverridden(type: FunctionType): boolean;
+    function isBuiltIn(type: FunctionType, name?: string | string[]): boolean;
     function getEffectiveParameterType(type: FunctionType, index: number): Type;
     function getEffectiveParameterDefaultArgType(type: FunctionType, index: number): Type | undefined;
-    function addParameter(type: FunctionType, param: FunctionParameter): void;
+    function addParameter(type: FunctionType, param: FunctionParam): void;
     function addPositionOnlyParameterSeparator(type: FunctionType): void;
     function addKeywordOnlyParameterSeparator(type: FunctionType): void;
     function getEffectiveReturnType(type: FunctionType, includeInferred?: boolean): Type | undefined;
 }
-export interface OverloadedFunctionType extends TypeBase {
-    category: TypeCategory.OverloadedFunction;
+export interface OverloadedFunctionTypeDetailsPriv {
     overloads: FunctionType[];
 }
+export interface OverloadedFunctionType extends TypeBase<TypeCategory.OverloadedFunction> {
+    priv: OverloadedFunctionTypeDetailsPriv;
+}
 export declare namespace OverloadedFunctionType {
     function create(overloads: FunctionType[]): OverloadedFunctionType;
     function addOverload(type: OverloadedFunctionType, functionType: FunctionType): void;
     function getOverloads(type: OverloadedFunctionType): FunctionType[];
     function getImplementation(type: OverloadedFunctionType): FunctionType | undefined;
 }
-export interface NeverType extends TypeBase {
-    category: TypeCategory.Never;
+export interface NeverTypeDetailsPriv {
     isNoReturn: boolean;
 }
+export interface NeverType extends TypeBase<TypeCategory.Never> {
+    priv: NeverTypeDetailsPriv;
+}
 export declare namespace NeverType {
     function createNever(): NeverType;
     function createNoReturn(): NeverType;
     function convertToInstance(type: NeverType): NeverType;
 }
-export interface AnyType extends TypeBase {
-    category: TypeCategory.Any;
+export interface AnyTypeDetailsPriv {
     isEllipsis: boolean;
 }
+export interface AnyType extends TypeBase<TypeCategory.Any> {
+    priv: AnyTypeDetailsPriv;
+}
 export declare namespace AnyType {
     function create(isEllipsis?: boolean): AnyType;
     function createSpecialForm(): AnyType;
@@ -462,17 +495,19 @@ export declare namespace TypeCondition {
     function isCompatible(conditions1: TypeCondition[] | undefined, conditions2: TypeCondition[] | undefined): boolean;
 }
 export interface LiteralTypes {
-    literalStrMap?: Map<string, UnionableType> | undefined;
-    literalIntMap?: Map<bigint | number, UnionableType> | undefined;
-    literalEnumMap?: Map<string, UnionableType> | undefined;
+    literalStrMap: Map<string, UnionableType> | undefined;
+    literalIntMap: Map<bigint | number, UnionableType> | undefined;
+    literalEnumMap: Map<string, UnionableType> | undefined;
 }
-export interface UnionType extends TypeBase {
-    category: TypeCategory.Union;
+export interface UnionTypeDetailsPriv {
     subtypes: UnionableType[];
     literalInstances: LiteralTypes;
     literalClasses: LiteralTypes;
-    typeAliasSources?: Set<UnionType>;
-    includesRecursiveTypeAlias?: boolean;
+    typeAliasSources: Set<UnionType> | undefined;
+    includesRecursiveTypeAlias: boolean;
+}
+export interface UnionType extends TypeBase<TypeCategory.Union> {
+    priv: UnionTypeDetailsPriv;
 }
 export declare namespace UnionType {
     function create(): UnionType;
@@ -487,24 +522,27 @@ export declare const enum Variance {
     Covariant = 3,
     Contravariant = 4
 }
-export interface TypeVarDetails {
+export interface RecursiveAliasInfo {
+    name: string;
+    scopeId: TypeVarScopeId;
+    isPep695Syntax: boolean;
+    typeParameters: TypeVarType[] | undefined;
+}
+export interface TypeVarDetailsShared {
     name: string;
     constraints: Type[];
-    boundType?: Type | undefined;
-    isDefaultExplicit?: boolean;
+    boundType: Type | undefined;
+    isDefaultExplicit: boolean;
     defaultType: Type;
     isParamSpec: boolean;
     isVariadic: boolean;
     declaredVariance: Variance;
     isSynthesized: boolean;
-    isSynthesizedSelf?: boolean | undefined;
-    synthesizedIndex?: number | undefined;
-    isExemptFromBoundCheck?: boolean;
-    isTypeParamSyntax?: boolean;
-    recursiveTypeAliasName?: string | undefined;
-    recursiveTypeAliasScopeId?: TypeVarScopeId | undefined;
-    recursiveTypeAliasIsPep695Syntax?: boolean;
-    recursiveTypeParameters?: TypeVarType[] | undefined;
+    isSynthesizedSelf: boolean;
+    synthesizedIndex: number | undefined;
+    isExemptFromBoundCheck: boolean;
+    isTypeParamSyntax: boolean;
+    recursiveAlias: RecursiveAliasInfo | undefined;
 }
 export type ParamSpecAccess = 'args' | 'kwargs';
 export declare const enum TypeVarScopeType {
@@ -512,9 +550,7 @@ export declare const enum TypeVarScopeType {
     Function = 1,
     TypeAlias = 2
 }
-export interface TypeVarType extends TypeBase {
-    category: TypeCategory.TypeVar;
-    details: TypeVarDetails;
+export interface TypeVarTypeDetailsPriv {
     scopeId?: TypeVarScopeId | undefined;
     scopeName?: string | undefined;
     scopeType?: TypeVarScopeType;
@@ -525,6 +561,10 @@ export interface TypeVarType extends TypeBase {
     computedVariance?: Variance;
     isInScopePlaceholder?: boolean;
 }
+export interface TypeVarType extends TypeBase<TypeCategory.TypeVar> {
+    shared: TypeVarDetailsShared;
+    priv: TypeVarTypeDetailsPriv;
+}
 export declare namespace TypeVarType {
     function createInstance(name: string): TypeVarType;
     function createInstantiable(name: string, isParamSpec?: boolean): TypeVarType;
@@ -570,6 +610,10 @@ export declare function removeUnknownFromUnion(type: Type): Type;
 export declare function removeUnbound(type: Type): Type;
 export declare function removeFromUnion(type: Type, removeFilter: (type: Type) => boolean): Type;
 export declare function findSubtype(type: Type, filter: (type: UnionableType | NeverType) => boolean): UnionableType | NeverType | undefined;
-export declare function combineTypes(subtypes: Type[], maxSubtypeCount?: number): Type;
+export interface CombineTypesOptions {
+    skipElideRedundantLiterals?: boolean;
+    maxSubtypeCount?: number;
+}
+export declare function combineTypes(subtypes: Type[], options?: CombineTypesOptions): Type;
 export declare function isSameWithoutLiteralValue(destType: Type, srcType: Type): boolean;
 export {};