@eagleoutice/flowr 2.2.12 → 2.2.13

package/control-flow/control-flow-graph.d.ts

@@ -0,0 +1,247 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { MergeableRecord } from '../util/objects';
+import type { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
+export declare enum CfgVertexType {
+    /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
+    MidMarker = "mid",
+    /** The explicit exit-nodes to ensure the hammock property */
+    EndMarker = "end",
+    /** something like an if, assignment, ... even though in the classical sense of R they are still expressions */
+    Statement = "stm",
+    /** something like an addition, ... */
+    Expression = "expr",
+    /** a (as far as R allows this) 'basic' block */
+    Block = "blk"
+}
+export declare const enum CfgEdgeType {
+    /** a flow dependency */
+    Fd = 0,
+    /** a control dependency */
+    Cd = 1
+}
+export declare function edgeTypeToString(type: CfgEdgeType): string;
+/**
+ * A plain vertex in the {@link ControlFlowGraph}.
+ * Please use {@link CfgSimpleVertex} to refer to all potential vertex types within the graph.
+ */
+interface CfgBaseVertex extends MergeableRecord {
+    /** the type of the vertex */
+    type: CfgVertexType;
+    /** the id of the vertex, for non-blocks this should directly relate to the AST node */
+    id: NodeId;
+    /** child nodes attached to this one */
+    children?: NodeId[];
+    /** if the vertex calls a function, this links all targets of this call */
+    callTargets?: Set<NodeId>;
+}
+interface CfgWithMarker extends CfgBaseVertex {
+    /** mid-markers linked to this statement */
+    mid?: NodeId[];
+    /** end-markers linked to this statement */
+    end?: NodeId[];
+}
+export interface CfgStatementVertex extends CfgWithMarker {
+    type: CfgVertexType.Statement;
+}
+export interface CfgExpressionVertex extends CfgWithMarker {
+    type: CfgVertexType.Expression;
+}
+export interface CfgWithRoot extends CfgBaseVertex {
+    /** the vertex for which this is a marker */
+    root: NodeId;
+}
+export interface CfgMidMarkerVertex extends CfgWithRoot {
+    type: CfgVertexType.MidMarker;
+    kind: string;
+}
+export interface CfgEndMarkerVertex extends CfgWithRoot {
+    type: CfgVertexType.EndMarker;
+}
+export interface CfgBasicBlockVertex extends CfgBaseVertex {
+    type: CfgVertexType.Block;
+    /** The vertices that are part of this block, only connected by FDs, vertices should never occur in multiple bbs */
+    elems: readonly Exclude<CfgSimpleVertex, CfgBasicBlockVertex>[];
+}
+/**
+ * A vertex in the {@link ControlFlowGraph}.
+ */
+export type CfgSimpleVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgMidMarkerVertex | CfgEndMarkerVertex;
+export declare function equalVertex(a: CfgSimpleVertex, b: CfgSimpleVertex): boolean;
+interface CfgFlowDependencyEdge extends MergeableRecord {
+    label: CfgEdgeType.Fd;
+}
+interface CfgControlDependencyEdge extends MergeableRecord {
+    label: CfgEdgeType.Cd;
+    /** the id which caused the control dependency */
+    caused: NodeId;
+    /** is the control dependency satisfied with a true condition or is it negated (e.g., else-branch)? */
+    when: typeof RTrue | typeof RFalse;
+}
+export type CfgEdge = CfgFlowDependencyEdge | CfgControlDependencyEdge;
+/**
+ * A read-only view of the {@link ControlFlowGraph}.
+ */
+export interface ReadOnlyControlFlowGraph {
+    /**
+     * Get all ids of the root vertices &mdash; vertices that are not part of
+     * any function definition or basic block and hence part of the "top-level" control flow.
+     *
+     * This is the pendant of {@link DataflowGraph#rootIds|rootIds()} on a {@link DataflowGraph}.
+     *
+     * @see {@link ReadOnlyControlFlowGraph#vertices|vertices()} - for a way to get all vertices in the graph.
+     * @see {@link ReadOnlyControlFlowGraph#getVertex|getVertex()} - for a way to get a specific vertex by its id.
+     * @see {@link ReadOnlyControlFlowGraph#edges|edges()} - for a way to get all edges in the graph.
+     */
+    readonly rootIds: () => ReadonlySet<NodeId>;
+    /**
+     * Provide a view of all vertices in the graph.
+     *
+     * @param includeBasicBlockElements - if true, the elements of basic block elements are included in the result, otherwise this will only the basic blocks themselves
+     *
+     * @see {@link ReadOnlyControlFlowGraph#rootVertexIds|rootVertexIds()} - for a way to get the root vertices of the graph.
+     * @see {@link ReadOnlyControlFlowGraph#getVertex|getVertex()} - for a way to get a specific vertex by its id.
+     * @see {@link ReadOnlyControlFlowGraph#edges|edges()} - for a way to get all edges in the graph.
+     */
+    readonly vertices: (includeBasicBlockElements: boolean) => ReadonlyMap<NodeId, CfgSimpleVertex>;
+    /**
+     * Get all edges in the graph, independent of their sources and targets.
+     * If you are only interested in the edges of a specific node, please use {@link ReadOnlyControlFlowGraph#outgoingEdges|outgoingEdges()} or {@link ReadOnlyControlFlowGraph#ingoingEdges|ingoingEdges()}.
+     *
+     * This is the pendant of {@link DataflowGraph#edges|edges()} on a {@link DataflowGraph}.
+     */
+    readonly edges: () => ReadonlyMap<NodeId, ReadonlyMap<NodeId, CfgEdge>>;
+    /**
+     * Receive all outgoing edges of a given vertex.
+     *
+     * This is the pendant of {@link DataflowGraph#ingoingEdges|ingoingEdges()} on a {@link DataflowGraph}.
+     *
+     * @see {@link ReadOnlyControlFlowGraph#ingoingEdges|ingoingEdges()} - for a way to get all ingoing edges of a vertex.
+     */
+    readonly outgoingEdges: (id: NodeId) => ReadonlyMap<NodeId, CfgEdge> | undefined;
+    /**
+     * Receive all ingoing edges of a given vertex.
+     *
+     * This is the pendant of {@link DataflowGraph#outgoingEdges|outgoingEdges()} on a {@link DataflowGraph}.
+     *
+     * @see {@link ReadOnlyControlFlowGraph#outgoingEdges|outgoingEdges()} - for a way to get all outgoing edges of a vertex.
+     */
+    readonly ingoingEdges: (id: NodeId) => ReadonlyMap<NodeId, CfgEdge> | undefined;
+    /**
+     * Retrieve a vertex by its id.
+     *
+     * @param id - the id of the vertex to retrieve
+     * @param includeBlocks - if true, the elements of basic block elements are included in the result, otherwise this will only the basic blocks themselves
+     *
+     * This is the pendant of {@link DataflowGraph#getVertex|getVertex()} on a {@link DataflowGraph}.
+     */
+    readonly getVertex: (id: NodeId, includeBlocks?: boolean) => CfgSimpleVertex | undefined;
+    /**
+     * Check if a vertex with the given id exists in the graph.
+     *
+     * @param id - the id of the vertex to check
+     * @param includeBlocks - if true, the elements of basic block elements are included in the check, otherwise this will only check the basic blocks themselves
+     *
+     * This is the pendant of {@link DataflowGraph#hasVertex|hasVertex()} on a {@link DataflowGraph}.
+     */
+    readonly hasVertex: (id: NodeId, includeBlocks?: boolean) => boolean;
+    /**
+     * Obtain the basic block associated with the given element id (i.e. if this is an element within a basic block, return the blockit belongs to).
+     */
+    readonly getBasicBlock: (elemId: NodeId) => CfgBasicBlockVertex | undefined;
+    /**
+     * Returns true if the graph may contain basic blocks and false if we know that it does not.
+     * This can be used for optimizations.
+     */
+    readonly mayHaveBasicBlocks: () => boolean;
+}
+/**
+ * This class represents the control flow graph of an R program.
+ * The control flow may be hierarchical when confronted with function definitions (see {@link CfgSimpleVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
+ *
+ * There are two very simple visitors to traverse a CFG:
+ * - {@link visitCfgInOrder} visits the graph in the order of the vertices
+ * - {@link visitCfgInReverseOrder} visits the graph in reverse order
+ *
+ * If you want to prohibit modification, please refer to the {@link ReadOnlyControlFlowGraph} interface.
+ */
+export declare class ControlFlowGraph<Vertex extends CfgSimpleVertex = CfgSimpleVertex> implements ReadOnlyControlFlowGraph {
+    private readonly rootVertices;
+    private readonly vertexInformation;
+    /** the basic block children map contains a mapping of ids to all vertices that are nested in basic blocks, mapping them to the Id of the block they appear in */
+    private readonly bbChildren;
+    /** basic block agnostic edges */
+    private readonly edgeInformation;
+    /** used as an optimization to avoid unnecessary lookups */
+    private _mayHaveBasicBlocks;
+    /**
+     * Add a new vertex to the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addEdge|addEdge()} - to add an edge
+     */
+    addVertex(vertex: Vertex, rootVertex?: boolean): this;
+    /**
+     * Add a new edge to the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addVertex|addVertex()} - to add vertices
+     * @see {@link ControlFlowGraph#addEdges|addEdges()} - to add multiple edges at once
+     */
+    addEdge(from: NodeId, to: NodeId, edge: CfgEdge): this;
+    /**
+     * Add multiple edges from a given source vertex to the control flow graph.
+     */
+    addEdges(from: NodeId, to: Map<NodeId, CfgEdge>): this;
+    outgoingEdges(node: NodeId): ReadonlyMap<NodeId, CfgEdge> | undefined;
+    ingoingEdges(id: NodeId): ReadonlyMap<NodeId, CfgEdge> | undefined;
+    rootIds(): ReadonlySet<NodeId>;
+    vertices(includeBasicBlockElements?: boolean): ReadonlyMap<NodeId, CfgSimpleVertex>;
+    getBasicBlock(elemId: NodeId): CfgBasicBlockVertex | undefined;
+    edges(): ReadonlyMap<NodeId, ReadonlyMap<NodeId, CfgEdge>>;
+    /**
+     * Retrieve a vertex by its id.
+     */
+    getVertex(id: NodeId, includeBlocks?: boolean): CfgSimpleVertex | undefined;
+    hasVertex(id: NodeId, includeBlocks?: boolean): boolean;
+    mayHaveBasicBlocks(): boolean;
+    /**
+     * This removes the vertex and all edges to and from it.
+     * @param id - the id of the vertex to remove
+     *
+     * @see {@link ControlFlowGraph#addVertex|addVertex()} - to add a vertex
+     * @see {@link ControlFlowGraph#removeEdge|removeEdge()} - to remove a specific edge
+     */
+    removeVertex(id: NodeId): this;
+    /**
+     * Removes a all direct edges between `from` and `to` from the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addEdge|addEdge()} - to add an edge
+     * @see {@link ControlFlowGraph#removeVertex|removeVertex()} - to remove a vertex and all its edges
+     */
+    removeEdge(from: NodeId, to: NodeId): this;
+    /** merges b into a */
+    mergeTwoBasicBlocks(a: NodeId, b: NodeId): this;
+    /**
+     * Merge another control flow graph into this one.
+     * @param other - the other control flow graph to merge into this one
+     * @param forceNested - should the other graph be assumed to be fully nested (e.g., within a function definition).
+     *
+     * This is the pendant of {@link DataflowGraph#mergeWith|mergeWith()} on a {@link DataflowGraph}.
+     */
+    mergeWith(other: ControlFlowGraph<Vertex>, forceNested?: boolean): this;
+}
+/** Summarizes the control information of a program */
+export interface ControlFlowInformation<Vertex extends CfgSimpleVertex = CfgSimpleVertex> extends MergeableRecord {
+    /** all active 'return'(-like) unconditional jumps */
+    returns: NodeId[];
+    /** all active 'break'(-like) unconditional jumps */
+    breaks: NodeId[];
+    /** all active 'next'(-like) unconditional jumps */
+    nexts: NodeId[];
+    /** intended to construct a hammock graph, with 0 exit points representing a block that should not be part of the CFG (like a comment) */
+    entryPoints: NodeId[];
+    /** See {@link ControlFlowInformation#entryPoints|entryPoints} */
+    exitPoints: NodeId[];
+    /** the control flow graph summarizing the flow information */
+    graph: ControlFlowGraph<Vertex>;
+}
+export declare function emptyControlFlowInformation(): ControlFlowInformation;
+export {};

package/control-flow/control-flow-graph.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlFlowGraph = exports.CfgVertexType = void 0;
+exports.edgeTypeToString = edgeTypeToString;
+exports.equalVertex = equalVertex;
+exports.emptyControlFlowInformation = emptyControlFlowInformation;
+const assert_1 = require("../util/assert");
+var CfgVertexType;
+(function (CfgVertexType) {
+    /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
+    CfgVertexType["MidMarker"] = "mid";
+    /** The explicit exit-nodes to ensure the hammock property */
+    CfgVertexType["EndMarker"] = "end";
+    /** something like an if, assignment, ... even though in the classical sense of R they are still expressions */
+    CfgVertexType["Statement"] = "stm";
+    /** something like an addition, ... */
+    CfgVertexType["Expression"] = "expr";
+    /** a (as far as R allows this) 'basic' block */
+    CfgVertexType["Block"] = "blk";
+})(CfgVertexType || (exports.CfgVertexType = CfgVertexType = {}));
+function edgeTypeToString(type) {
+    switch (type) {
+        case 0 /* CfgEdgeType.Fd */:
+            return 'FD';
+        case 1 /* CfgEdgeType.Cd */:
+            return 'CD';
+        default:
+            throw new Error(`Unknown edge type ${JSON.stringify(type)}`);
+    }
+}
+function equalVertex(a, b) {
+    if (a.type !== b.type || a.id !== b.id) {
+        return false;
+    }
+    else if (a.type === CfgVertexType.Block && b.type === CfgVertexType.Block) {
+        return a.elems.length === b.elems.length && a.elems.every((e, i) => e.id === b.elems[i].id);
+    }
+    else if (a.type === CfgVertexType.MidMarker && b.type === CfgVertexType.MidMarker) {
+        return a.kind === b.kind && a.root === b.root;
+    }
+    else if (a.type === CfgVertexType.EndMarker && b.type === CfgVertexType.EndMarker) {
+        return a.root === b.root;
+    }
+    return true;
+}
+/**
+ * This class represents the control flow graph of an R program.
+ * The control flow may be hierarchical when confronted with function definitions (see {@link CfgSimpleVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
+ *
+ * There are two very simple visitors to traverse a CFG:
+ * - {@link visitCfgInOrder} visits the graph in the order of the vertices
+ * - {@link visitCfgInReverseOrder} visits the graph in reverse order
+ *
+ * If you want to prohibit modification, please refer to the {@link ReadOnlyControlFlowGraph} interface.
+ */
+class ControlFlowGraph {
+    rootVertices = new Set();
+    vertexInformation = new Map();
+    /** the basic block children map contains a mapping of ids to all vertices that are nested in basic blocks, mapping them to the Id of the block they appear in */
+    bbChildren = new Map();
+    /** basic block agnostic edges */
+    edgeInformation = new Map();
+    /** used as an optimization to avoid unnecessary lookups */
+    _mayHaveBasicBlocks = false;
+    /**
+     * Add a new vertex to the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addEdge|addEdge()} - to add an edge
+     */
+    addVertex(vertex, rootVertex = true) {
+        (0, assert_1.guard)(!this.vertexInformation.has(vertex.id), `Node with id ${vertex.id} already exists`);
+        if (vertex.type === CfgVertexType.Block) {
+            this._mayHaveBasicBlocks = true;
+            if (vertex.elems.some(e => this.bbChildren.has(e.id) || this.rootVertices.has(e.id))) {
+                throw new Error(`Vertex ${vertex.id} contains vertices that are already part of the graph`);
+            }
+            for (const elem of vertex.elems) {
+                this.bbChildren.set(elem.id, vertex.id);
+            }
+        }
+        this.vertexInformation.set(vertex.id, vertex);
+        if (rootVertex) {
+            this.rootVertices.add(vertex.id);
+        }
+        return this;
+    }
+    /**
+     * Add a new edge to the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addVertex|addVertex()} - to add vertices
+     * @see {@link ControlFlowGraph#addEdges|addEdges()} - to add multiple edges at once
+     */
+    addEdge(from, to, edge) {
+        const edgesFrom = this.edgeInformation.get(from) ?? new Map();
+        if (!this.edgeInformation.has(from)) {
+            this.edgeInformation.set(from, edgesFrom);
+        }
+        edgesFrom.set(to, edge);
+        return this;
+    }
+    /**
+     * Add multiple edges from a given source vertex to the control flow graph.
+     */
+    addEdges(from, to) {
+        const edgesFrom = this.edgeInformation.get(from) ?? new Map();
+        if (!this.edgeInformation.has(from)) {
+            this.edgeInformation.set(from, edgesFrom);
+        }
+        for (const [toId, edge] of to) {
+            edgesFrom.set(toId, edge);
+        }
+        return this;
+    }
+    outgoingEdges(node) {
+        return this.edgeInformation.get(node);
+    }
+    ingoingEdges(id) {
+        const edges = new Map();
+        for (const [source, outgoing] of this.edgeInformation.entries()) {
+            if (outgoing.has(id)) {
+                edges.set(source, outgoing.get(id));
+            }
+        }
+        return edges;
+    }
+    rootIds() {
+        return this.rootVertices;
+    }
+    vertices(includeBasicBlockElements = true) {
+        if (includeBasicBlockElements) {
+            const all = new Map(this.vertexInformation);
+            for (const [id, block] of this.bbChildren.entries()) {
+                const blockVertex = all.get(block);
+                if (blockVertex === undefined || blockVertex.type !== CfgVertexType.Block) {
+                    continue;
+                }
+                const elem = blockVertex.elems.find(e => e.id === id);
+                if (elem !== undefined) {
+                    all.set(id, elem);
+                }
+            }
+            return all;
+        }
+        else {
+            return this.vertexInformation;
+        }
+    }
+    getBasicBlock(elemId) {
+        const block = this.bbChildren.get(elemId);
+        if (block === undefined) {
+            return undefined;
+        }
+        const blockVertex = this.vertexInformation.get(block);
+        if (blockVertex === undefined || blockVertex.type !== CfgVertexType.Block) {
+            return undefined;
+        }
+        return blockVertex;
+    }
+    edges() {
+        return this.edgeInformation;
+    }
+    /**
+     * Retrieve a vertex by its id.
+     */
+    getVertex(id, includeBlocks = true) {
+        const res = this.vertexInformation.get(id);
+        if (res || !includeBlocks) {
+            return res;
+        }
+        const block = this.bbChildren.get(id);
+        if (block === undefined) {
+            return undefined;
+        }
+        const blockVertex = this.vertexInformation.get(block);
+        if (blockVertex === undefined || blockVertex.type !== CfgVertexType.Block) {
+            return undefined;
+        }
+        blockVertex.elems.find(e => e.id === id);
+    }
+    hasVertex(id, includeBlocks = true) {
+        return this.vertexInformation.has(id) || (this._mayHaveBasicBlocks && includeBlocks && this.bbChildren.has(id));
+    }
+    mayHaveBasicBlocks() {
+        return this._mayHaveBasicBlocks;
+    }
+    /**
+     * This removes the vertex and all edges to and from it.
+     * @param id - the id of the vertex to remove
+     *
+     * @see {@link ControlFlowGraph#addVertex|addVertex()} - to add a vertex
+     * @see {@link ControlFlowGraph#removeEdge|removeEdge()} - to remove a specific edge
+     */
+    removeVertex(id) {
+        this.vertexInformation.delete(id);
+        this.edgeInformation.delete(id);
+        this.bbChildren.delete(id);
+        // remove all bbChildren with id as target
+        for (const [a, b] of this.bbChildren.entries()) {
+            if (b === id) {
+                this.bbChildren.delete(a);
+            }
+        }
+        for (const edges of this.edgeInformation.values()) {
+            edges.delete(id);
+        }
+        this.rootVertices.delete(id);
+        return this;
+    }
+    /**
+     * Removes a all direct edges between `from` and `to` from the control flow graph.
+     *
+     * @see {@link ControlFlowGraph#addEdge|addEdge()} - to add an edge
+     * @see {@link ControlFlowGraph#removeVertex|removeVertex()} - to remove a vertex and all its edges
+     */
+    removeEdge(from, to) {
+        const edges = this.edgeInformation.get(from);
+        if (edges) {
+            edges.delete(to);
+            if (edges.size === 0) {
+                this.edgeInformation.delete(from);
+            }
+        }
+        return this;
+    }
+    /** merges b into a */
+    mergeTwoBasicBlocks(a, b) {
+        const aVertex = this.getVertex(a);
+        const bVertex = this.getVertex(b);
+        if (!aVertex || !bVertex || aVertex.type !== CfgVertexType.Block || bVertex.type !== CfgVertexType.Block) {
+            return this;
+        }
+        const bElems = bVertex.elems;
+        aVertex.elems = aVertex.elems.concat(bElems);
+        // update cache
+        for (const elem of bElems) {
+            this.bbChildren.set(elem.id, a);
+        }
+        // drop all edges from a to b
+        this.removeEdge(a, b);
+        const bOutgoing = this.outgoingEdges(b);
+        this.removeVertex(b);
+        // reroute all edge from b to a
+        for (const [to, edge] of bOutgoing ?? []) {
+            this.addEdge(a, to, edge);
+        }
+        return this;
+    }
+    /**
+     * Merge another control flow graph into this one.
+     * @param other - the other control flow graph to merge into this one
+     * @param forceNested - should the other graph be assumed to be fully nested (e.g., within a function definition).
+     *
+     * This is the pendant of {@link DataflowGraph#mergeWith|mergeWith()} on a {@link DataflowGraph}.
+     */
+    mergeWith(other, forceNested = false) {
+        this._mayHaveBasicBlocks ||= other._mayHaveBasicBlocks;
+        const roots = other.rootVertices;
+        if (this._mayHaveBasicBlocks) {
+            for (const [id, node] of other.vertexInformation) {
+                this.addVertex(node, forceNested ? false : roots.has(id));
+            }
+        }
+        else {
+            for (const [id, node] of other.vertexInformation) {
+                this.vertexInformation.set(id, node);
+            }
+            if (!forceNested) {
+                for (const root of roots) {
+                    this.rootVertices.add(root);
+                }
+            }
+        }
+        for (const [from, edges] of other.edgeInformation) {
+            this.addEdges(from, edges);
+        }
+        return this;
+    }
+}
+exports.ControlFlowGraph = ControlFlowGraph;
+function emptyControlFlowInformation() {
+    return {
+        returns: [],
+        breaks: [],
+        nexts: [],
+        entryPoints: [],
+        exitPoints: [],
+        graph: new ControlFlowGraph()
+    };
+}
+//# sourceMappingURL=control-flow-graph.js.map

package/control-flow/dfg-cfg-guided-visitor.d.ts

@@ -0,0 +1,32 @@
+import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../dataflow/info';
+import type { DataflowGraphVertexArgument, DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue, DataflowGraphVertexVariableDefinition } from '../dataflow/graph/vertex';
+import type { BasicCfgGuidedVisitorConfiguration } from './basic-cfg-guided-visitor';
+import { BasicCfgGuidedVisitor } from './basic-cfg-guided-visitor';
+export interface DataflowCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowInformation = DataflowInformation> extends BasicCfgGuidedVisitorConfiguration<Cfg> {
+    readonly dataflow: Dfg;
+}
+/**
+ * This visitor extends on the {@link BasicCfgGuidedVisitor} by dispatching visitors based on the dataflow graph.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+export declare class DataflowAwareCfgGuidedVisitor<Cfg extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowInformation = DataflowInformation, Config extends DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg> = DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg>> extends BasicCfgGuidedVisitor<Cfg, Config> {
+    /**
+     * Get the dataflow graph vertex for the given id
+     */
+    protected getDataflowGraph(id: NodeId): DataflowGraphVertexArgument | undefined;
+    protected onStatementNode(node: CfgStatementVertex): void;
+    protected onExpressionNode(node: CfgExpressionVertex): void;
+    private onExprOrStmtNode;
+    /**
+     * called for every cfg vertex that has no corresponding dataflow vertex.
+     */
+    protected visitUnknown(_vertex: CfgStatementVertex | CfgExpressionVertex): void;
+    protected visitValue(_val: DataflowGraphVertexValue): void;
+    protected visitVariableUse(_use: DataflowGraphVertexUse): void;
+    protected visitVariableDefinition(_def: DataflowGraphVertexVariableDefinition): void;
+    protected visitFunctionDefinition(_def: DataflowGraphVertexFunctionDefinition): void;
+    protected visitFunctionCall(_call: DataflowGraphVertexFunctionCall): void;
+}

package/control-flow/dfg-cfg-guided-visitor.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowAwareCfgGuidedVisitor = void 0;
+const vertex_1 = require("../dataflow/graph/vertex");
+const basic_cfg_guided_visitor_1 = require("./basic-cfg-guided-visitor");
+const assert_1 = require("../util/assert");
+/**
+ * This visitor extends on the {@link BasicCfgGuidedVisitor} by dispatching visitors based on the dataflow graph.
+ *
+ * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
+ */
+class DataflowAwareCfgGuidedVisitor extends basic_cfg_guided_visitor_1.BasicCfgGuidedVisitor {
+    /**
+     * Get the dataflow graph vertex for the given id
+     */
+    getDataflowGraph(id) {
+        return this.config.dataflow.graph.getVertex(id);
+    }
+    onStatementNode(node) {
+        super.onStatementNode(node);
+        this.onExprOrStmtNode(node);
+    }
+    onExpressionNode(node) {
+        super.onExpressionNode(node);
+        this.onExprOrStmtNode(node);
+    }
+    onExprOrStmtNode(node) {
+        const dfgVertex = this.getDataflowGraph(node.id);
+        if (!dfgVertex) {
+            this.visitUnknown(node);
+            return;
+        }
+        const tag = dfgVertex.tag;
+        switch (tag) {
+            case vertex_1.VertexType.Use:
+                this.visitVariableUse(dfgVertex);
+                break;
+            case vertex_1.VertexType.VariableDefinition:
+                this.visitVariableDefinition(dfgVertex);
+                break;
+            case vertex_1.VertexType.FunctionDefinition:
+                this.visitFunctionDefinition(dfgVertex);
+                break;
+            case vertex_1.VertexType.FunctionCall:
+                this.visitFunctionCall(dfgVertex);
+                break;
+            case vertex_1.VertexType.Value:
+                this.visitValue(dfgVertex);
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(tag);
+        }
+    }
+    /**
+     * called for every cfg vertex that has no corresponding dataflow vertex.
+     */
+    visitUnknown(_vertex) {
+    }
+    visitValue(_val) {
+    }
+    visitVariableUse(_use) {
+    }
+    visitVariableDefinition(_def) {
+    }
+    visitFunctionDefinition(_def) {
+    }
+    visitFunctionCall(_call) {
+    }
+}
+exports.DataflowAwareCfgGuidedVisitor = DataflowAwareCfgGuidedVisitor;
+//# sourceMappingURL=dfg-cfg-guided-visitor.js.map

package/control-flow/diff-cfg.d.ts

@@ -0,0 +1,11 @@
+import type { NamedGraph } from '../util/diff-graph';
+import { GraphDifferenceReport } from '../util/diff-graph';
+import type { GenericDiffConfiguration } from '../util/diff';
+import type { ControlFlowGraph } from './control-flow-graph';
+/**
+ * Compare two control flow graphs and return a report on the differences.
+ * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+ *
+ * @see {@link diffOfDataflowGraphs} - for dataflow graphs
+ */
+export declare function diffOfControlFlowGraphs(left: NamedGraph<ControlFlowGraph>, right: NamedGraph<ControlFlowGraph>, config?: Partial<GenericDiffConfiguration>): GraphDifferenceReport;