@zzzen/pyright-internal 1.2.0-dev.20260920 → 1.2.0-dev.20260927

package/dist/analyzer/overloadResultController.d.ts

@@ -0,0 +1,227 @@
+import { Diagnostic } from '../common/diagnostic';
+import { TextRangeDiagnosticSink } from '../common/diagnosticSink';
+import { AssignmentNode, CallNode, ExpressionNode, FunctionNode, ModuleNode, NameNode, ParseNode } from '../parser/parseNodes';
+import { AnalyzerNodeInfoReader } from './analyzerNodeInfo';
+import { LocalOverloadAdmission } from './overloadResultAdmission';
+import { AutomaticOverloadSelection } from './overloadResultSelector';
+import { EvalFlags, EvaluationCacheIsolation, EvaluationOperationController, EvaluationOperationRequest, TypeEvaluator, TypeResult } from './typeEvaluatorTypes';
+import { Type, TypeCategory } from './types';
+import { InferenceContext } from './typeUtils';
+export interface OverloadResultLimits {
+    nodes: number;
+    records: number;
+    rootNodes: number;
+    graphUnits: number;
+    candidates: number;
+    calls: number;
+    proofUnits: number;
+}
+export interface FixedOverloadResultSeed {
+    node: CallNode;
+    candidates: (evaluator: TypeEvaluator) => readonly Type[];
+    uncertainty: TypeCategory.Any | TypeCategory.Unknown;
+}
+export interface ExperimentalOverloadResultOptions {
+    seeds?: (module: ModuleNode) => readonly FixedOverloadResultSeed[];
+    automatic?: boolean;
+    limits?: Partial<OverloadResultLimits>;
+    producerCalls?: number;
+    consumerCalls?: number;
+    checkerHandoff?: boolean;
+    observe?: (event: OverloadResultEvent) => void;
+}
+export type OverloadResultEvent = {
+    kind: 'activationProbe';
+    node: CallNode;
+    selection: AutomaticOverloadSelection;
+} | {
+    kind: 'selection';
+    node: CallNode;
+    selection: AutomaticOverloadSelection;
+} | {
+    kind: 'scan';
+    module: ModuleNode;
+    nodes: number;
+    seeds: number;
+    cutoff: boolean;
+} | {
+    kind: 'admission';
+    module: ModuleNode;
+    admission: LocalOverloadAdmission;
+} | {
+    kind: 'enter';
+    module: ModuleNode;
+    root: ParseNode;
+    mode: OperationMode;
+} | {
+    kind: 'trial';
+    root: ParseNode;
+    mode: OperationMode;
+    result?: TypeResult;
+    diagnostics: readonly Diagnostic[];
+    failed: boolean;
+    retained: boolean;
+    nestedSpeculative: boolean;
+    exception: boolean;
+} | {
+    kind: 'value';
+    root: ParseNode;
+    canonical: TypeResult;
+    baseline: TypeResult;
+    cutoff: boolean;
+} | {
+    kind: 'project';
+    node: ExpressionNode;
+    source: Type;
+    result: TypeResult;
+    mode: OperationMode;
+} | {
+    kind: 'publish';
+    root: ParseNode;
+    diagnostics: readonly Diagnostic[];
+} | {
+    kind: 'retire';
+    module: ModuleNode;
+    outcomes: number;
+} | {
+    kind: 'context';
+    node: ExpressionNode;
+    flags: EvalFlags;
+    context?: InferenceContext;
+    result: TypeResult;
+} | {
+    kind: 'beforeCall';
+    node: CallNode;
+    mode: OperationMode;
+    seen: ReadonlyMap<ParseNode, TypeResult>;
+};
+export interface LocalOverloadOperation {
+    root: ParseNode;
+    statement: AssignmentNode | ExpressionNode;
+    expression: ExpressionNode;
+    assignment?: AssignmentNode;
+    target?: NameNode;
+    annotated: boolean;
+    fn: FunctionNode;
+    nodes: readonly ParseNode[];
+    ids: ReadonlySet<number>;
+    valueNodes: ReadonlySet<ParseNode>;
+    seed?: FixedOverloadResultSeed & {
+        automatic?: boolean;
+    };
+    admitted: boolean;
+    reader: boolean;
+    flags?: EvalFlags;
+    context?: InferenceContext;
+}
+type OperationMode = 'baseline' | 'candidate' | 'reader' | 'check-baseline' | 'check-candidate' | 'materialize-baseline' | 'materialize-witness' | 'context';
+export interface OverloadResultWork {
+    candidateCalls: number;
+    candidateTrials: number;
+    ordinaryCalls: number;
+    ordinaryRequests: number;
+    projectionSetup: number;
+    contextualRequests: number;
+    retryReservations: number;
+    checkerHandoffs: number;
+}
+export declare class ExperimentalOverloadResultController implements EvaluationOperationController {
+    private _options;
+    private _evaluator;
+    readonly roots: Map<ParseNode, ReadonlySet<number>>;
+    private readonly _limits;
+    private readonly _info;
+    private readonly _generations;
+    private readonly _emptyModules;
+    private readonly _expiredModules;
+    private _active?;
+    private _disposed;
+    private _activationBoundary;
+    private _activationCanRestart;
+    private _canActivate?;
+    private _flushActivation?;
+    private _discovering;
+    private readonly _activationChecked;
+    private readonly _activated;
+    private readonly _pendingActivation;
+    private _cacheIsolation?;
+    private _select?;
+    private _captureQueryCache?;
+    private _checkerHandoff?;
+    private _automaticWork;
+    constructor(_options: ExperimentalOverloadResultOptions, _evaluator: () => TypeEvaluator, reader: AnalyzerNodeInfoReader);
+    get isAutomatic(): boolean;
+    get hasPendingActivation(): boolean;
+    installCacheIsolation: (isolation: EvaluationCacheIsolation) => void;
+    installSelector: (select: (node: CallNode, limit: number, proofUnits: number) => AutomaticOverloadSelection) => void;
+    installActivationBoundary: (canActivate: () => boolean, flush: () => void) => void;
+    installQueryCache: (capture: (root: ParseNode, node: NameNode) => (() => boolean) | undefined) => void;
+    installCheckerHandoff: (handoff: (root: ParseNode, expression: ExpressionNode, result: TypeResult, callback: () => void) => boolean) => void;
+    getAutomaticStats(): {
+        reasons: {
+            [k: string]: number;
+        };
+        modules: number;
+        nodes: number;
+        scanCutoffs: number;
+        seeds: number;
+        graphAdmitted: number;
+        selections: number;
+        selected: number;
+        proofUnits: number;
+        activationArgumentChecks: number;
+        activationProbes: number;
+        activationProofUnits: number;
+        activations: number;
+    };
+    getDiagnosticSink(node: ParseNode): TextRangeDiagnosticSink | undefined;
+    needsActivationBoundary(): boolean | undefined;
+    runWithActivation<T>(callback: () => T): T;
+    considerActivation(node: CallNode, args: readonly {
+        argType: Type;
+    }[]): void;
+    finishActivation(): void;
+    dispose: () => void;
+    dispatch: (_node: ExpressionNode, _flags: EvalFlags, _context?: InferenceContext) => TypeResult | undefined;
+    route: (request: EvaluationOperationRequest) => {
+        result?: TypeResult;
+    } | undefined;
+    project: (node: ExpressionNode, result: TypeResult) => TypeResult;
+    beforeCall: (node: CallNode) => void;
+    check: (module: ModuleNode) => {
+        walk: (node: ParseNode, callback: () => void) => void;
+        dispose: () => void;
+    } | undefined;
+    evict(module: ModuleNode): void;
+    getStats(module: ModuleNode): {
+        records: number;
+        outcomes: number;
+        variants: number;
+        slots: number;
+        candidateCallCeiling: number;
+        interruptedSlots: number;
+        candidateCalls: number;
+        candidateTrials: number;
+        ordinaryCalls: number;
+        ordinaryRequests: number;
+        projectionSetup: number;
+        contextualRequests: number;
+        retryReservations: number;
+        checkerHandoffs: number;
+    } | undefined;
+    private _emit;
+    private _retire;
+    private _ensure;
+    private _isEnabled;
+    private _reserveGeneration;
+    private _key;
+    private _definition;
+    private _inputs;
+    private _trial;
+    private _build;
+    private _variant;
+    private _expressionRecord;
+    private _queryOutcome;
+    private _query;
+}
+export {};