@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261108

package/dist/analyzer/typeEvaluator/memberResolution.d.ts

@@ -0,0 +1,79 @@
+import { DiagnosticAddendum } from '../../common/diagnostic';
+import { CallNode, ClassNode, ExpressionNode, FunctionNode, ImportAsNode, ImportFromAsNode, ImportFromNode, NameNode, ParseNode, StringNode } from '../../parser/parseNodes';
+import * as AnalyzerNodeInfo from '../analyzerNodeInfo';
+import { CodeFlowEngine } from '../codeFlowEngine';
+import { ConstraintTracker } from '../constraintTracker';
+import { Declaration } from '../declaration';
+import { ResolvedAliasInfo } from '../declarationUtils';
+import { Scope, SymbolWithScope } from '../scope';
+import { Symbol, SynthesizedTypeInfo } from '../symbol';
+import { EvaluatorOptions, MemberAccessTypeResult, SymbolResolutionStackEntry } from '../typeEvaluator/internals';
+import { AbstractSymbol, Arg, CallResult, ClassTypeResult, EffectiveTypeResult, EvaluatorUsage, ExpectedTypeOptions, ExpectedTypeResult, FunctionTypeResult, PrefetchedTypes, ResolveAliasOptions, SymbolDeclInfo, TypeEvaluator, TypeResult } from '../typeEvaluatorTypes';
+import { ClassType, FunctionType, OverloadedType, Type, TypeCondition, TypeVarType } from '../types';
+import { ClassMember, InferenceContext, MemberAccessFlags } from '../typeUtils';
+interface Context {
+    readonly addClassEntryDeclsForKeywordArgIfPresent: (baseType: ClassType, paramName: string, decls: Declaration[], synthesizedTypes: SynthesizedTypeInfo[]) => void;
+    readonly addSymbolDeclInfo: (symbol: Symbol, decls: Declaration[], synthesizedTypes: SynthesizedTypeInfo[], preferTypedDeclarations?: boolean) => void;
+    readonly shouldFallBackToClassEntryForKeywordArg: (baseType: ClassType, paramName: string) => boolean;
+    readonly tryAddPartialKeywordParamDecls: (baseType: Type, callNode: CallNode, paramName: string, decls: Declaration[]) => boolean;
+    readonly addDiagnostic: TypeEvaluator['addDiagnostic'];
+    readonly codeFlowEngine: CodeFlowEngine;
+    readonly evaluateTypesForStatement: (node: ParseNode) => void;
+    readonly evaluatorOptions: EvaluatorOptions;
+    readonly getAbstractSymbolInfo: (classType: ClassType, symbolName: string) => AbstractSymbol | undefined;
+    readonly getBoundMagicMethod: (classType: ClassType, memberName: string, selfType?: ClassType | TypeVarType | undefined, errorNode?: ExpressionNode | undefined, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
+    readonly getEffectiveTypeOfSymbol: (symbol: Symbol) => Type;
+    readonly getEffectiveTypeOfSymbolForUsage: (symbol: Symbol, usageNode?: NameNode, useLastDecl?: boolean) => EffectiveTypeResult;
+    readonly getExpectedType: (node: ExpressionNode) => ExpectedTypeResult | undefined;
+    readonly getInferredTypeOfDeclaration: (symbol: Symbol, decl: Declaration) => Type | undefined;
+    readonly getScopeForNode: (node: ParseNode) => Scope | undefined;
+    readonly getScopeIdForNode: (node: ParseNode) => string;
+    readonly getType: (node: ExpressionNode) => Type | undefined;
+    readonly getTypeClassType: () => ClassType | undefined;
+    readonly getTypeOfAnnotation: (node: ExpressionNode, options?: ExpectedTypeOptions) => Type;
+    readonly getTypeOfBoundMember: (errorNode: ExpressionNode | undefined, objectType: ClassType, memberName: string, usage?: EvaluatorUsage, diag?: DiagnosticAddendum | undefined, flags?: MemberAccessFlags, selfType?: ClassType | TypeVarType, recursionCount?: number) => TypeResult | undefined;
+    readonly getTypeOfClass: (node: ClassNode) => ClassTypeResult | undefined;
+    readonly getTypeOfFunction: (node: FunctionNode) => FunctionTypeResult | undefined;
+    readonly inferReturnTypeIfNecessary: (type: Type) => void;
+    readonly isFlowPathBetweenNodes: (sourceNode: ParseNode, sinkNode: ParseNode, allowSelf?: boolean) => boolean;
+    readonly isLegalTypeAliasExpressionForm: (node: ExpressionNode, allowStrLiteral: boolean) => boolean;
+    readonly isSymbolValidTypeExpression: (type: Type, includesVarDecl: boolean) => boolean;
+    readonly makeTopLevelTypeVarsConcrete: (type: Type, makeParamSpecsConcrete?: boolean, conditionFilter?: TypeCondition[]) => Type;
+    readonly nodeInfo: AnalyzerNodeInfo.AnalyzerNodeInfoAccessor;
+    readonly partiallySpecializeBoundMethod: (baseType: ClassType, memberType: FunctionType, diag: DiagnosticAddendum | undefined, recursionCount: number, firstParamType: ClassType | TypeVarType | undefined, stripFirstParam?: boolean) => FunctionType | undefined;
+    readonly prefetched: Partial<PrefetchedTypes> | undefined;
+    readonly resolveAliasDeclarationWithInfo: (declaration: Declaration, resolveLocalNames: boolean, options?: ResolveAliasOptions) => ResolvedAliasInfo | undefined;
+    readonly symbolResolutionStack: SymbolResolutionStackEntry[];
+    readonly validateCallArgs: (errorNode: ExpressionNode, argList: Arg[], callTypeResult: TypeResult, constraints: ConstraintTracker | undefined, skipUnknownArgCheck: boolean | undefined, inferenceContext: InferenceContext | undefined, recursionCount?: number) => CallResult;
+    readonly validateInitSubclassArgs: (node: ClassNode, classType: ClassType) => void;
+}
+export declare function createMemberResolution(context: Context): {
+    pushSymbolResolution: (symbol: Symbol, declaration: Declaration) => boolean;
+    popSymbolResolution: (symbol: Symbol) => boolean;
+    setSymbolResolutionPartialType: (symbol: Symbol, declaration: Declaration, type: Type) => void;
+    getSymbolResolutionPartialType: (symbol: Symbol, declaration: Declaration) => Type | undefined;
+    isDeclaredTypeAlias: (expression: ExpressionNode) => boolean;
+    validateSymbolIsTypeExpression: (node: ExpressionNode, type: Type, includesVarDecl: boolean) => Type;
+    bindMethodForMemberAccess: (type: Type, concreteType: FunctionType | OverloadedType, memberInfo: ClassMember | undefined, classType: ClassType, selfType: ClassType | TypeVarType | undefined, flags: MemberAccessFlags, memberName: string, usage: EvaluatorUsage, diag: DiagnosticAddendum | undefined, recursionCount?: number) => TypeResult;
+    isAsymmetricDescriptorClass: (classType: ClassType) => boolean;
+    applyAttributeAccessOverride: (errorNode: ExpressionNode, classType: ClassType, usage: EvaluatorUsage, memberName: string, selfType?: ClassType | TypeVarType) => MemberAccessTypeResult | undefined;
+    synthesizeTypeAliasPlaceholder: (nameNode: NameNode, isTypeAliasType?: boolean) => TypeVarType;
+    getAliasedSymbolTypeForName: (node: ImportAsNode | ImportFromAsNode | ImportFromNode, name: string) => Type | undefined;
+    lookUpSymbolRecursive: (node: ParseNode, name: string, honorCodeFlow: boolean, preferGlobalScope?: boolean) => SymbolWithScope | undefined;
+    getDeclInfoForStringNode: (node: StringNode) => SymbolDeclInfo | undefined;
+    getDeclInfoForNameNode: (node: NameNode, skipUnreachableCode?: boolean) => SymbolDeclInfo | undefined;
+    includesVariableTypeDecl: (decls: Declaration[]) => boolean;
+    getDeclaredReturnType: (node: FunctionNode) => Type | undefined;
+    getCallbackProtocolType: (objType: ClassType, recursionCount?: number) => FunctionType | OverloadedType | undefined;
+    getAbstractSymbols: (classType: ClassType) => AbstractSymbol[];
+    bindFunctionToClassOrObject: (baseType: ClassType | undefined, memberType: FunctionType | OverloadedType, memberClass?: ClassType, treatConstructorAsClassMethod?: boolean, selfType?: ClassType | TypeVarType, diag?: DiagnosticAddendum, recursionCount?: number) => FunctionType | OverloadedType | undefined;
+    isExplicitTypeAliasDeclaration: (decl: Declaration) => boolean;
+    isPossibleTypeAliasDeclaration: (decl: Declaration) => boolean;
+    isLegalImplicitTypeAliasType: (type: Type) => boolean;
+    getTypeOfMember: (member: ClassMember) => Type;
+    getTypeOfMemberInternal: (errorNode: ExpressionNode | undefined, member: ClassMember, selfClass: ClassType | TypeVarType | undefined, flags: MemberAccessFlags) => TypeResult | undefined;
+    getIndexOfSymbolResolution: (symbol: Symbol, declaration: Declaration) => number;
+    getDeclarationFromKeywordParam: (type: FunctionType, paramName: string) => Declaration | undefined;
+    getAliasFromImport: (node: NameNode) => NameNode | undefined;
+};
+export {};