import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
import { CfgVertex } from '../control-flow/control-flow-graph';
import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
import type { DataflowGraph } from '../dataflow/graph/graph';
import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexVariableDefinition } from '../dataflow/graph/vertex';
import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
import { type AnyAbstractDomain } from './domains/abstract-domain';
import type { StateAbstractDomain } from './domains/state-abstract-domain';
import { MutableStateAbstractDomain } from './domains/state-abstract-domain';
import { BuiltInProcName } from '../dataflow/environments/built-in-proc-name';
export type AbsintVisitorConfiguration = Omit<SemanticCfgGuidedVisitorConfiguration<NoInfo, ControlFlowInformation, NormalizedAst>, 'defaultVisitingOrder' | 'defaultVisitingType'>;
/**
 * A control flow graph visitor to perform abstract interpretation.
 *
 * However, the visitor does not yet support inter-procedural abstract interpretation and abstract condition semantics.
 */
export declare abstract class AbstractInterpretationVisitor<Domain extends AnyAbstractDomain, Config extends AbsintVisitorConfiguration = AbsintVisitorConfiguration> extends SemanticCfgGuidedVisitor<NoInfo, ControlFlowInformation, NormalizedAst, DataflowGraph, Config & {
    defaultVisitingOrder: 'forward';
    defaultVisitingType: 'exit';
}> {
    /**
     * The abstract trace of the abstract interpretation visitor mapping node IDs to the abstract state at the respective node.
     */
    protected readonly trace: Map<NodeId, MutableStateAbstractDomain<Domain>>;
    /**
     * The current abstract state domain at the currently processed AST node.
     */
    private _currentState;
    /**
     * A set of nodes representing variable definitions that have already been visited but whose assignment has not yet been processed.
     */
    private readonly unassigned;
    /**
     * Whether the current abstract state has been copied/cloned and is save to modify in place.
     */
    private stateCopied;
    constructor(config: Config);
    get currentState(): StateAbstractDomain<Domain>;
    removeState(node: NodeId): void;
    updateState(node: NodeId, value: Domain): void;
    /**
     * Resolves the inferred abstract value of an AST node.
     * This requires that the abstract interpretation visitor has been completed, or at least started.
     * @param id    - The ID of the node to get the inferred value for
     * @param state - An optional state abstract domain used to resolve the inferred abstract value (defaults to the state at the requested node)
     * @returns The inferred abstract value of the node, or `undefined` if no value was inferred for the node
     */
    getAbstractValue(id: RNode<ParentInformation> | NodeId | undefined, state?: StateAbstractDomain<Domain>): Domain | undefined;
    /**
     * Gets the inferred abstract state at the location of a specific AST node.
     * This requires that the abstract interpretation visitor has been completed, or at least started.
     * @param id - The ID of the node to get the abstract state at
     * @returns The abstract state at the node, or `undefined` if the node has no abstract state (i.e. the node has not been visited or is unreachable).
     */
    getAbstractState(id: NodeId | undefined): StateAbstractDomain<Domain> | undefined;
    /**
     * Gets the inferred abstract state at the end of the program (exit nodes of the control flow graph).
     * This requires that the abstract interpretation visitor has been completed, or at least started.
     * @returns The inferred abstract state at the end of the program
     */
    getEndState(): StateAbstractDomain<Domain>;
    /**
     * Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
     * @returns The inferred abstract trace of the program
     */
    getAbstractTrace(): ReadonlyMap<NodeId, StateAbstractDomain<Domain>>;
    start(): void;
    protected startVisitor(start: readonly NodeId[]): void;
    protected visitNode(vertexId: NodeId): boolean;
    protected onDispatchFunctionCallOrigin(call: DataflowGraphVertexFunctionCall, origin: BuiltInProcName): void;
    protected onVariableDefinition({ vertex }: {
        vertex: DataflowGraphVertexVariableDefinition;
    }): void;
    protected onAssignmentCall({ target, source }: {
        call: DataflowGraphVertexFunctionCall;
        target?: NodeId;
        source?: NodeId;
    }): void;
    protected onReplacementCall({ target }: {
        call: DataflowGraphVertexFunctionCall;
        target?: NodeId;
        source?: NodeId;
    }): void;
    /**
     * This event triggers for every function call that is not a condition, loop, assignment, replacement call, or access operation.
     *
     *
     * For example, this triggers for `data.frame` in `x <- data.frame(id = 1:5, name = letters[1:5])`.
     *
     * This bundles all function calls that are no conditions, loops, assignments, replacement calls, and access operations.
     * @protected
     */
    protected onFunctionCall(_data: {
        call: DataflowGraphVertexFunctionCall;
    }): void;
    /** Gets all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
    protected getPredecessorNodes(vertexId: NodeId): NodeId[];
    /** Gets each variable origin that has already been visited and whose assignment has already been processed */
    protected getVariableOrigins(nodeId: NodeId): NodeId[];
    /** We only perform widening at `for`, `while`, or `repeat` loops with more than one ingoing CFG edge */
    protected isWideningPoint(nodeId: NodeId): boolean;
    /**
     * Checks whether a control flow graph vertex should be skipped during visitation.
     * By default, we only process entry vertices of widening points, vertices of leaf nodes, and exit vertices (no entry nodes of complex nodes).
     */
    protected shouldSkipVertex(vertex: CfgVertex): boolean;
    /**
     * Whether widening should be performed at a widening point.
     * By default, we perform widening when the number of visits of the widening point reaches the widening threshold of the config.
     */
    protected shouldWiden(wideningPoint: CfgVertex): boolean;
}