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

package/dist/analyzer/types.d.ts

@@ -1,5 +1,5 @@
 import { Uri } from '../common/uri/uri';
-import { ArgumentNode, NameNode, ParameterCategory } from '../parser/parseNodes';
+import { ArgumentNode, NameNode, ParamCategory } from '../parser/parseNodes';
 import { ClassDeclaration, FunctionDeclaration, SpecialBuiltInClassDeclaration } from './declaration';
 import { Symbol, SymbolTable } from './symbol';
 export declare const enum TypeCategory {
@@ -51,9 +51,9 @@ export interface TypeAliasInfo {
     fileUri: Uri;
     typeVarScopeId: TypeVarScopeId;
     isPep695Syntax: boolean;
-    typeParameters: TypeVarType[] | undefined;
+    typeParams: TypeVarType[] | undefined;
     usageVariance: Variance[] | undefined;
-    typeArguments: Type[] | undefined;
+    typeArgs: Type[] | undefined;
 }
 interface CachedTypeInfo {
     instantiableType?: Type;
@@ -62,13 +62,13 @@ interface CachedTypeInfo {
     typeBaseInstanceType?: Type;
     requiresSpecialization?: boolean;
 }
-interface TypeBaseProps {
+export interface TypeBaseProps {
     instantiableDepth: number | undefined;
     specialForm: ClassType | undefined;
     typeAliasInfo: TypeAliasInfo | undefined;
     condition: TypeCondition[] | undefined;
 }
-interface TypeBase<T extends TypeCategory> {
+export interface TypeBase<T extends TypeCategory> {
     category: T;
     flags: TypeFlags;
     props: TypeBaseProps | undefined;
@@ -99,19 +99,19 @@ export declare namespace UnboundType {
     function create(): UnboundType;
     function convertToInstance(type: UnboundType): UnboundType;
 }
-export interface UnknownTypeDetailsPriv {
+export interface UnknownDetailsPriv {
     isIncomplete: boolean;
     possibleType: Type | undefined;
 }
 export interface UnknownType extends TypeBase<TypeCategory.Unknown> {
-    priv: UnknownTypeDetailsPriv;
+    priv: UnknownDetailsPriv;
 }
 export declare namespace UnknownType {
     function create(isIncomplete?: boolean): UnknownType;
     function createPossibleType(possibleType: Type, isIncomplete: boolean): UnknownType;
     function convertToInstance(type: UnknownType): UnknownType;
 }
-export interface ModuleTypeDetailsPriv {
+export interface ModuleDetailsPriv {
     fields: SymbolTable;
     docString: string | undefined;
     notPresentFieldType: AnyType | UnknownType | undefined;
@@ -120,7 +120,7 @@ export interface ModuleTypeDetailsPriv {
     fileUri: Uri;
 }
 export interface ModuleType extends TypeBase<TypeCategory.Module> {
-    priv: ModuleTypeDetailsPriv;
+    priv: ModuleDetailsPriv;
 }
 export declare namespace ModuleType {
     function create(moduleName: string, fileUri: Uri, symbolTable?: SymbolTable): ModuleType;
@@ -200,7 +200,7 @@ interface ClassDetailsShared {
     declaredMetaclass?: ClassType | UnknownType | undefined;
     effectiveMetaclass?: ClassType | UnknownType | undefined;
     fields: SymbolTable;
-    typeParameters: TypeVarType[];
+    typeParams: TypeVarType[];
     typeVarScopeId?: TypeVarScopeId | undefined;
     docString?: string | undefined;
     dataClassEntries?: DataClassEntry[] | undefined;
@@ -216,7 +216,7 @@ interface ClassDetailsShared {
     calculateInheritedSlotsNamesDeferred?: () => void;
     inheritedSlotsNamesCached?: string[];
 }
-export interface TupleTypeArgument {
+export interface TupleTypeArg {
     type: Type;
     isUnbounded: boolean;
     isOptional?: boolean;
@@ -226,13 +226,11 @@ export interface PropertyMethodInfo {
     classType: ClassType | undefined;
 }
 export interface ClassDetailsPriv {
-    typeArguments?: Type[] | undefined;
-    typeGuardType?: Type | undefined;
-    isStrictTypeGuard?: boolean;
+    typeArgs?: Type[] | undefined;
     isEmptyContainer?: boolean | undefined;
-    tupleTypeArguments?: TupleTypeArgument[] | undefined;
+    tupleTypeArgs?: TupleTypeArg[] | undefined;
     isUnpacked?: boolean | undefined;
-    isTypeArgumentExplicit?: boolean | undefined;
+    isTypeArgExplicit?: boolean | undefined;
     includeSubclasses?: boolean;
     includePromotions?: boolean;
     literalValue?: LiteralValue | undefined;
@@ -254,7 +252,7 @@ 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;
     function cloneAsInstantiable(type: ClassType, includeSubclasses?: boolean): ClassType;
-    function cloneForSpecialization(classType: ClassType, typeArguments: Type[] | undefined, isTypeArgumentExplicit: boolean, includeSubclasses?: boolean, tupleTypeArguments?: TupleTypeArgument[], isEmptyContainer?: boolean): ClassType;
+    function specialize(classType: ClassType, typeArgs: Type[] | undefined, isTypeArgExplicit?: boolean, includeSubclasses?: boolean, tupleTypeArgs?: TupleTypeArg[], isEmptyContainer?: boolean): ClassType;
     function cloneIncludeSubclasses(classType: ClassType, includeSubclasses?: boolean): ClassType;
     function cloneWithLiteral(classType: ClassType, value: LiteralValue | undefined): ClassType;
     function cloneForDeprecatedInstance(type: ClassType, deprecatedMessage?: string): ClassType;
@@ -262,7 +260,6 @@ export declare namespace ClassType {
     function cloneForNarrowedTypedDictEntries(classType: ClassType, narrowedEntries?: Map<string, TypedDictEntry>): ClassType;
     function cloneForPartialTypedDict(classType: ClassType): ClassType;
     function cloneRemoveTypePromotions(classType: ClassType): ClassType;
-    function cloneForTypeGuard(classType: ClassType, typeGuardType: Type, isStrictTypeGuard: boolean): ClassType;
     function cloneForSymbolTableUpdate(classType: ClassType): ClassType;
     function cloneForUnpacked(classType: ClassType, isUnpacked?: boolean): ClassType;
     function cloneWithNewFlags(classType: ClassType, newFlags: ClassTypeFlags): ClassType;
@@ -304,7 +301,7 @@ export declare namespace ClassType {
     function hasCustomClassGetItem(classType: ClassType): boolean;
     function isTupleClass(classType: ClassType): boolean;
     function isReadOnlyInstanceVariables(classType: ClassType): boolean;
-    function getTypeParameters(classType: ClassType): TypeVarType[];
+    function getTypeParams(classType: ClassType): TypeVarType[];
     function derivesFromAnyOrUnknown(classType: ClassType): boolean;
     function getSymbolTable(classType: ClassType): SymbolTable;
     function getInheritedSlotsNames(classType: ClassType): string[] | undefined;
@@ -320,14 +317,14 @@ export declare enum FunctionParamFlags {
     TypeInferred = 4
 }
 export interface FunctionParam {
-    category: ParameterCategory;
+    category: ParamCategory;
     type: Type;
     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 create(category: ParamCategory, type: Type, flags?: FunctionParamFlags, name?: string, defaultType?: Type): FunctionParam;
     function isNameSynthesized(param: FunctionParam): boolean;
     function isTypeDeclared(param: FunctionParam): boolean;
     function isTypeInferred(param: FunctionParam): boolean;
@@ -362,7 +359,7 @@ interface FunctionDetailsShared {
     fullName: string;
     moduleName: string;
     flags: FunctionTypeFlags;
-    typeParameters: TypeVarType[];
+    typeParams: TypeVarType[];
     parameters: FunctionParam[];
     declaredReturnType: Type | undefined;
     declaration: FunctionDeclaration | undefined;
@@ -395,7 +392,6 @@ export interface FunctionDetailsPriv {
     boundToType?: ClassType | undefined;
     preBoundFlags?: FunctionTypeFlags;
     overloaded?: OverloadedFunctionType;
-    trackedSignatures?: SignatureWithOffsets[];
     isCallableWithTypeArgs?: boolean;
 }
 export interface FunctionType extends TypeBase<TypeCategory.Function> {
@@ -409,19 +405,19 @@ export declare namespace FunctionType {
     function clone(type: FunctionType, stripFirstParam?: boolean, boundToType?: ClassType, boundTypeVarScopeId?: TypeVarScopeId): FunctionType;
     function cloneAsInstance(type: FunctionType): FunctionType;
     function cloneAsInstantiable(type: FunctionType): FunctionType;
-    function cloneForSpecialization(type: FunctionType, specializedTypes: SpecializedFunctionTypes, specializedInferredReturnType: Type | undefined): FunctionType;
+    function specialize(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, newConstructorScopeId: TypeVarScopeId | undefined, typeParameters: TypeVarType[], trackedSignatures?: SignatureWithOffsets[]): FunctionType;
+    function cloneWithNewTypeVarScopeId(type: FunctionType, newScopeId: TypeVarScopeId | undefined, newConstructorScopeId: TypeVarScopeId | undefined, typeParams: TypeVarType[]): FunctionType;
     function cloneWithDocString(type: FunctionType, docString?: string): FunctionType;
     function cloneWithDeprecatedMessage(type: FunctionType, deprecatedMessage?: string): FunctionType;
     function cloneRemoveParamSpecArgsKwargs(type: FunctionType, stripPositionOnlySeparator?: boolean): FunctionType;
-    function getParamSpecFromArgsKwargs(type: FunctionType): TypeVarType | undefined;
-    function addParamSpecVariadics(type: FunctionType, paramSpec: TypeVarType): void;
-    function addDefaultParameters(type: FunctionType, useUnknown?: boolean): void;
+    function getParamSpecFromArgsKwargs(type: FunctionType): ParamSpecType | undefined;
+    function addParamSpecVariadics(type: FunctionType, paramSpec: ParamSpecType): void;
+    function addDefaultParams(type: FunctionType, useUnknown?: boolean): void;
     function addHigherOrderTypeVarScopeIds(functionType: FunctionType, scopeIds: (TypeVarScopeId | undefined)[] | TypeVarScopeId | undefined): void;
-    function getDefaultParameters(useUnknown?: boolean): FunctionParam[];
-    function hasDefaultParameters(functionType: FunctionType): boolean;
+    function getDefaultParams(useUnknown?: boolean): FunctionParam[];
+    function hasDefaultParams(functionType: FunctionType): boolean;
     function isInstanceMethod(type: FunctionType): boolean;
     function isConstructorMethod(type: FunctionType): boolean;
     function isStaticMethod(type: FunctionType): boolean;
@@ -431,7 +427,7 @@ export declare namespace FunctionType {
     function isSynthesizedMethod(type: FunctionType): boolean;
     function isTypeCheckOnly(type: FunctionType): boolean;
     function isOverloaded(type: FunctionType): boolean;
-    function isDefaultParameterCheckDisabled(type: FunctionType): boolean;
+    function isDefaultParamCheckDisabled(type: FunctionType): boolean;
     function isAsync(type: FunctionType): boolean;
     function isStubDefinition(type: FunctionType): boolean;
     function isPyTypedDefinition(type: FunctionType): boolean;
@@ -442,18 +438,18 @@ export declare namespace FunctionType {
     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: FunctionParam): void;
-    function addPositionOnlyParameterSeparator(type: FunctionType): void;
-    function addKeywordOnlyParameterSeparator(type: FunctionType): void;
+    function getEffectiveParamType(type: FunctionType, index: number): Type;
+    function getEffectiveParamDefaultArgType(type: FunctionType, index: number): Type | undefined;
+    function addParam(type: FunctionType, param: FunctionParam): void;
+    function addPositionOnlyParamSeparator(type: FunctionType): void;
+    function addKeywordOnlyParamSeparator(type: FunctionType): void;
     function getEffectiveReturnType(type: FunctionType, includeInferred?: boolean): Type | undefined;
 }
-export interface OverloadedFunctionTypeDetailsPriv {
+export interface OverloadedFunctionDetailsPriv {
     overloads: FunctionType[];
 }
 export interface OverloadedFunctionType extends TypeBase<TypeCategory.OverloadedFunction> {
-    priv: OverloadedFunctionTypeDetailsPriv;
+    priv: OverloadedFunctionDetailsPriv;
 }
 export declare namespace OverloadedFunctionType {
     function create(overloads: FunctionType[]): OverloadedFunctionType;
@@ -461,22 +457,22 @@ export declare namespace OverloadedFunctionType {
     function getOverloads(type: OverloadedFunctionType): FunctionType[];
     function getImplementation(type: OverloadedFunctionType): FunctionType | undefined;
 }
-export interface NeverTypeDetailsPriv {
+export interface NeverDetailsPriv {
     isNoReturn: boolean;
 }
 export interface NeverType extends TypeBase<TypeCategory.Never> {
-    priv: NeverTypeDetailsPriv;
+    priv: NeverDetailsPriv;
 }
 export declare namespace NeverType {
     function createNever(): NeverType;
     function createNoReturn(): NeverType;
     function convertToInstance(type: NeverType): NeverType;
 }
-export interface AnyTypeDetailsPriv {
+export interface AnyDetailsPriv {
     isEllipsis: boolean;
 }
 export interface AnyType extends TypeBase<TypeCategory.Any> {
-    priv: AnyTypeDetailsPriv;
+    priv: AnyDetailsPriv;
 }
 export declare namespace AnyType {
     function create(isEllipsis?: boolean): AnyType;
@@ -499,7 +495,7 @@ export interface LiteralTypes {
     literalIntMap: Map<bigint | number, UnionableType> | undefined;
     literalEnumMap: Map<string, UnionableType> | undefined;
 }
-export interface UnionTypeDetailsPriv {
+export interface UnionDetailsPriv {
     subtypes: UnionableType[];
     literalInstances: LiteralTypes;
     literalClasses: LiteralTypes;
@@ -507,7 +503,7 @@ export interface UnionTypeDetailsPriv {
     includesRecursiveTypeAlias: boolean;
 }
 export interface UnionType extends TypeBase<TypeCategory.Union> {
-    priv: UnionTypeDetailsPriv;
+    priv: UnionDetailsPriv;
 }
 export declare namespace UnionType {
     function create(): UnionType;
@@ -526,16 +522,20 @@ export interface RecursiveAliasInfo {
     name: string;
     scopeId: TypeVarScopeId;
     isPep695Syntax: boolean;
-    typeParameters: TypeVarType[] | undefined;
+    typeParams: TypeVarType[] | undefined;
+}
+export declare enum TypeVarKind {
+    TypeVar = 0,
+    TypeVarTuple = 1,
+    ParamSpec = 2
 }
 export interface TypeVarDetailsShared {
+    kind: TypeVarKind;
     name: string;
     constraints: Type[];
     boundType: Type | undefined;
     isDefaultExplicit: boolean;
     defaultType: Type;
-    isParamSpec: boolean;
-    isVariadic: boolean;
     declaredVariance: Variance;
     isSynthesized: boolean;
     isSynthesizedSelf: boolean;
@@ -550,38 +550,64 @@ export declare const enum TypeVarScopeType {
     Function = 1,
     TypeAlias = 2
 }
-export interface TypeVarTypeDetailsPriv {
+export interface TypeVarDetailsPriv {
     scopeId?: TypeVarScopeId | undefined;
     scopeName?: string | undefined;
     scopeType?: TypeVarScopeType;
     nameWithScope?: string | undefined;
-    isVariadicUnpacked?: boolean | undefined;
-    isVariadicInUnion?: boolean | undefined;
-    paramSpecAccess?: ParamSpecAccess;
     computedVariance?: Variance;
     isInScopePlaceholder?: boolean;
+    externalTypeVar?: TypeVarType | undefined;
 }
 export interface TypeVarType extends TypeBase<TypeCategory.TypeVar> {
     shared: TypeVarDetailsShared;
-    priv: TypeVarTypeDetailsPriv;
+    priv: TypeVarDetailsPriv;
+}
+export interface ParamSpecDetailsPriv extends TypeVarDetailsPriv {
+    paramSpecAccess?: ParamSpecAccess;
+    externalTypeVar?: ParamSpecType | undefined;
+}
+export interface ParamSpecType extends TypeVarType {
+    shared: TypeVarDetailsShared & {
+        kind: TypeVarKind.ParamSpec;
+    };
+    priv: ParamSpecDetailsPriv;
+}
+export declare namespace ParamSpecType {
+    function getUnknown(): FunctionType;
+}
+export interface TypeVarTupleDetailsPriv extends TypeVarDetailsPriv {
+    isVariadicUnpacked?: boolean | undefined;
+    isVariadicInUnion?: boolean | undefined;
+    externalTypeVar?: TypeVarTupleType | undefined;
+}
+export interface TypeVarTupleType extends TypeVarType {
+    shared: TypeVarDetailsShared & {
+        kind: TypeVarKind.TypeVarTuple;
+    };
+    priv: TypeVarTupleDetailsPriv;
 }
 export declare namespace TypeVarType {
-    function createInstance(name: string): TypeVarType;
-    function createInstantiable(name: string, isParamSpec?: boolean): TypeVarType;
+    function createInstance(name: string, kind?: TypeVarKind): TypeVarType;
+    function createInstantiable(name: string, kind?: TypeVarKind): TypeVarType;
     function cloneAsInstance(type: TypeVarType): TypeVarType;
     function cloneAsInstantiable(type: TypeVarType): TypeVarType;
     function cloneForNewName(type: TypeVarType, name: string): TypeVarType;
-    function cloneForScopeId(type: TypeVarType, scopeId: string, scopeName: string, scopeType: TypeVarScopeType): TypeVarType;
-    function cloneForUnpacked(type: TypeVarType, isInUnion?: boolean): TypeVarType;
-    function cloneForPacked(type: TypeVarType): TypeVarType;
+    function cloneForScopeId(type: TypeVarType, scopeId: string, scopeName: string | undefined, scopeType: TypeVarScopeType | undefined): TypeVarType;
+    function cloneForUnpacked(type: TypeVarTupleType, isInUnion?: boolean): TypeVarTupleType;
+    function cloneForPacked(type: TypeVarTupleType): TypeVarTupleType;
     function cloneAsInvariant(type: TypeVarType): TypeVarType;
-    function cloneForParamSpecAccess(type: TypeVarType, access: ParamSpecAccess | undefined): TypeVarType;
+    function cloneForParamSpecAccess(type: ParamSpecType, access: ParamSpecAccess | undefined): ParamSpecType;
     function cloneAsSpecializedSelf(type: TypeVarType, specializedBoundType: Type): TypeVarType;
     function cloneAsInScopePlaceholder(type: TypeVarType, usageOffset?: number): TypeVarType;
     function makeNameWithScope(name: string, scopeId: string): string;
-    function addConstraint(typeVarType: TypeVarType, constraintType: Type): void;
+    function makeInternalScopeId(scopeId: TypeVarScopeId): TypeVarScopeId;
+    function makeInternalScopeId(scopeId: TypeVarScopeId | undefined): TypeVarScopeId | undefined;
+    function cloneWithInternalScopeId(type: TypeVarType): TypeVarType;
+    function hasInternalScopeId(type: TypeVarType): boolean;
+    function addConstraint(type: TypeVarType, constraintType: Type): void;
     function getNameWithScope(typeVarType: TypeVarType): string;
-    function getReadableName(typeVarType: TypeVarType): string;
+    function getReadableName(type: TypeVarType): string;
     function getVariance(type: TypeVarType): Variance.Invariant | Variance.Covariant | Variance.Contravariant;
     function isTypeAliasPlaceholder(type: TypeVarType): boolean;
 }
@@ -597,11 +623,11 @@ export declare function isInstantiableClass(type: Type): type is ClassType;
 export declare function isClassInstance(type: Type): type is ClassType;
 export declare function isModule(type: Type): type is ModuleType;
 export declare function isTypeVar(type: Type): type is TypeVarType;
-export declare function isVariadicTypeVar(type: Type): type is TypeVarType;
-export declare function isUnpackedVariadicTypeVar(type: Type): boolean;
+export declare function isParamSpec(type: Type): type is ParamSpecType;
+export declare function isTypeVarTuple(type: Type): type is TypeVarTupleType;
+export declare function isUnpackedTypeVarTuple(type: Type): type is TypeVarTupleType;
 export declare function isUnpackedClass(type: Type): type is ClassType;
 export declare function isUnpacked(type: Type): boolean;
-export declare function isParamSpec(type: Type): type is TypeVarType;
 export declare function isFunction(type: Type): type is FunctionType;
 export declare function isOverloadedFunction(type: Type): type is OverloadedFunctionType;
 export declare function getTypeAliasInfo(type: Type): TypeAliasInfo | undefined;