@eagleoutice/flowr 2.9.7 → 2.9.9

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

@@ -1,15 +1,31 @@
 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';
+import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
+/**
+ * The type of a vertex in the {@link ControlFlowGraph}.
+ * Please use the helper object (e.g. {@link CfgVertex#getType|getType()}) to work with vertices instead of directly accessing the properties.
+ */
 export declare enum CfgVertexType {
-    /** 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"
+    /**
+     * The explicit exit-nodes to ensure the hammock property.
+     * @see {@link CfgVertex.makeMarker|CfgVertex.makeMarker()} - for a helper function to create end marker vertices
+     */
+    Marker = 0,
+    /**
+     * something like an if, assignment, ... even though in the classical sense of R they are still expressions
+     * @see {@link CfgVertex.makeStatement|CfgVertex.makeStatement()} - for a helper function to create statement vertices
+     */
+    Statement = 1,
+    /**
+     * something like an addition, ...
+     * @see {@link CfgVertex.makeExpression|CfgVertex.makeExpression()} - for a helper function to create expression vertices
+     */
+    Expression = 2,
+    /**
+     * a (as far as R allows this) 'basic' block
+     * @see {@link CfgVertex.makeBlock|CfgVertex.makeBlock()} - for a helper function to create basic block vertices
+     */
+    Block = 3
 }
 export declare const enum CfgEdgeType {
     /** a flow dependency */
@@ -18,75 +34,362 @@ export declare const enum CfgEdgeType {
     Cd = 1
 }
 /**
- * Provide a string representation of the given edge type.
+ * A vertex in the {@link ControlFlowGraph} that may have markers attached to it (e.g., for function calls).
+ * - `type`: the type of the vertex, either a statement or an expression
+ * - `id`: the id of the vertex, which should directly relate to the AST node
+ * - `children`: child nodes attached to this one
+ * - `callTargets`: if the vertex calls a function, this links all targets of this call
  */
-export declare function edgeTypeToString(type: CfgEdgeType): string;
+type CfgBaseVertexWithMarker = [type: CfgVertexType, id: NodeId, mid?: NodeId[], end?: NodeId[], children?: NodeId[], callTargets?: Set<NodeId>];
 /**
- * A plain vertex in the {@link ControlFlowGraph}.
- * Please use {@link CfgSimpleVertex} to refer to all potential vertex types within the graph.
+ * @see {@link CfgBaseVertexWithMarker}
  */
-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 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>[];
-}
+export type CfgStatementVertex = [CfgVertexType.Statement, ...a: unknown[]] & CfgBaseVertexWithMarker;
 /**
- * A vertex in the {@link ControlFlowGraph}.
+ * @see {@link CfgBaseVertexWithMarker}
  */
-export type CfgSimpleVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgEndMarkerVertex;
+export type CfgExpressionVertex = [CfgVertexType.Expression, ...a: unknown[]] & CfgBaseVertexWithMarker;
 /**
- * Checks whether two vertices are equal.
+ * The root id is only stored if it is not derivable from the canonical id
+ * @see {@link CfgBaseVertexWithMarker}
  */
-export declare function equalVertex(a: CfgSimpleVertex, b: CfgSimpleVertex): boolean;
+export type CfgMarkerVertex = NodeId | [CfgVertexType.Marker, ...a: unknown[]] & [type: CfgVertexType, id: NodeId, rootId?: NodeId];
 /**
- * Checks whether a vertex is a marker vertex (i.e., does not correspond to an actual AST node
- * but is a marker in the control flow graph).
+ * A basic block vertex in the {@link ControlFlowGraph}.
+ * Contains the vertices that are part of this block, only connected by FDs, vertices should never occur in multiple bbs.
  */
-export declare function isMarkerVertex(vertex: CfgSimpleVertex): vertex is CfgEndMarkerVertex;
+export type CfgBasicBlockVertex = [CfgVertexType.Block, ...a: unknown[]] & [type: CfgVertexType, id: NodeId, elems: readonly Exclude<CfgVertex, CfgBasicBlockVertex>[]];
 /**
- * Get the root id of a vertex, i.e., the id of the AST node it corresponds to.
+ * A vertex in the {@link ControlFlowGraph}.
+ * Please use the helper object (e.g. {@link CfgVertex#getType|getType()}) to work with vertices instead of directly accessing the properties.
+ */
+export type CfgVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgMarkerVertex;
+/**
+ * Helper object for {@link CfgVertex} - a vertex in the {@link ControlFlowGraph} that may have markers attached to it (e.g., for function calls).
+ */
+export declare const CfgVertex: {
+    /**
+     * Create a new expression vertex with the given id, children, call targets, and markers.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param children    - child nodes attached to this one
+     * @param callTargets - if the vertex calls a function, this links all targets of this call
+     * @param mid         - the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers
+     * @param end         - the ids of the end-markers attached to this vertex, which should directly relate to the AST nodes of the end markers
+     * @see {@link CfgVertex#isExpression|isExpression()} - for a way to check whether a vertex is an expression vertex
+     */
+    readonly makeExpression: (this: void, id: NodeId, { children, mid, end, callTargets }?: {
+        children?: NodeId[];
+        callTargets?: Set<NodeId>;
+        mid?: NodeId[];
+        end?: NodeId[];
+    }) => CfgExpressionVertex;
+    /**
+     * A convenience function to create a new expression vertex with a canonical end marker ({@link CfgVertex#toExitId|toExitId()}) based on the given id and the given id as root id for the end marker.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param children    - child nodes attached to this one
+     * @param callTargets - if the vertex calls a function, this links all targets of this call
+     * @param mid         - the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers
+     * @see {@link CfgVertex#makeExpression|makeExpression()} - for a way to create expression vertices with a custom end marker
+     * @see {@link CfgVertex#makeExitMarker|makeExitMarker()} - for a helper function to create end marker vertices with a canonical id#
+     * @see {@link CfgVertex#toExitId|toExitId()} - for a way to convert the given id to a canonical end marker id
+     */
+    readonly makeExpressionWithEnd: (this: void, id: NodeId, { children, mid, callTargets }?: {
+        children?: NodeId[];
+        callTargets?: Set<NodeId>;
+        mid?: NodeId[];
+    }) => CfgExpressionVertex;
+    /**
+     * A convenience function to create a new statement vertex with a canonical end marker ({@link CfgVertex#toExitId|toExitId()}) based on the given id and the given id as root id for the end marker.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param children    - child nodes attached to this one
+     * @param callTargets - if the vertex calls a function, this links all targets of this call
+     * @param mid         - the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers
+     * @see {@link CfgVertex#makeExpression|makeExpression()} - for a way to create expression vertices with a custom end marker
+     * @see {@link CfgVertex#makeExitMarker|makeExitMarker()} - for a helper function to create end marker vertices with a canonical id#
+     * @see {@link CfgVertex#toExitId|toExitId()} - for a way to convert the given id to a canonical end marker id
+     */
+    readonly makeStatementWithEnd: (this: void, id: NodeId, { children, mid, callTargets }?: {
+        children?: NodeId[];
+        callTargets?: Set<NodeId>;
+        mid?: NodeId[];
+    }) => CfgStatementVertex;
+    /**
+     * Create a new statement vertex with the given id, children, call targets, and markers.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param children    - child nodes attached to this one
+     * @param callTargets - if the vertex calls a function, this links all targets of this call
+     * @param mid         - the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers
+     * @param end         - the ids of the end-markers attached to this vertex, which should directly relate to the AST nodes of the end markers
+     * @see {@link CfgVertex#isStatement|isStatement()} - for a way to check whether a vertex is a statement vertex
+     */
+    readonly makeStatement: (this: void, id: NodeId, { children, mid, end, callTargets }?: {
+        children?: NodeId[];
+        callTargets?: Set<NodeId>;
+        mid?: NodeId[];
+        end?: NodeId[];
+    }) => CfgStatementVertex;
+    /**
+     * A convenience function to create a new vertex which is either a statement or an expression.
+     */
+    readonly makeExprOrStm: (this: void, id: NodeId, type: CfgVertexType.Expression | CfgVertexType.Statement, { children, mid, end, callTargets }?: {
+        children?: NodeId[];
+        callTargets?: Set<NodeId>;
+        mid?: NodeId[];
+        end?: NodeId[];
+    }) => CfgExpressionVertex | CfgStatementVertex;
+    /**
+     * Create a new marker vertex with the given id, root id, children, and call targets.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param rootId      - the id of the AST node this end marker corresponds to
+     * @see {@link CfgVertex#isMarker|isMarker()} - for a way to check whether a vertex is an end marker vertex
+     * @see {@link CfgVertex#getRootId|getRootId()} - for a way to get the root id of an end marker vertex
+     * @see {@link CfgVertex#makeExitMarker|makeExitMarker()} - for a helper function to create end marker vertices with a canonical id
+     */
+    readonly makeMarker: (this: void, id: NodeId, rootId: NodeId) => CfgMarkerVertex;
+    /**
+     * A convenience function to create a new marker vertex with a canonical id ({@link CfgVertex#toExitId|toExitId()}) based on the given id and the given id as root id.
+     * @see {@link CfgVertex#makeMarker|makeMarker()} - for a way to create end marker vertices with a custom id
+     */
+    readonly makeExitMarker: (this: void, id: NodeId) => CfgMarkerVertex;
+    /**
+     * Create a new basic block vertex with the given id, elements, children, and call targets.
+     * @param id          - the id of the vertex, which should directly relate to the AST node
+     * @param elems       - the vertices that are part of this block, only connected by FDs, vertices should never occur in multiple bbs
+     * @see {@link CfgVertex#isBlock|isBlock()} - for a way to check whether a vertex is a basic block vertex
+     */
+    readonly makeBlock: (this: void, id: NodeId, elems: readonly Exclude<CfgVertex, CfgBasicBlockVertex>[]) => CfgBasicBlockVertex;
+    /**
+     * Check whether the given vertex is an expression vertex.
+     * @see {@link CfgVertex#makeExpression|makeExpression()} - for a way to create expression vertices
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex instead of checking against a given type
+     */
+    readonly isExpression: (this: void, vertex: CfgVertex | undefined) => vertex is CfgExpressionVertex;
+    /**
+     * Check whether the given vertex is a statement vertex.
+     * @see {@link CfgVertex#makeStatement|makeStatement()} - for a way to create statement vertices
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex instead of checking against a given type
+     */
+    readonly isStatement: (this: void, vertex: CfgVertex | undefined) => vertex is CfgStatementVertex;
+    /**
+     * Check whether the given vertex is an end marker vertex.
+     * @see {@link CfgVertex#makeMarker|makeMarker()} - for a way to create end marker vertices
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex instead of checking against a given type
+     */
+    readonly isMarker: (this: void, vertex: CfgVertex | undefined) => vertex is CfgMarkerVertex;
+    /**
+     * Check whether the given vertex is a basic block vertex.
+     * @see {@link CfgVertex#makeBlock|makeBlock()} - for a way to create basic block vertices
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex instead of checking against a given type
+     */
+    readonly isBlock: (this: void, vertex: CfgVertex | undefined) => vertex is CfgBasicBlockVertex;
+    /**
+     * Get the type of the given vertex.
+     * @example
+     * ```ts
+     * const vertex: CfgVertex = CfgVertex.makeExpr('node-1')
+     * console.log(CfgVertex.getType(vertex)); // Output: CfgVertexType.Expression
+     * ```
+     * @see {@link CfgVertex#isExpression|isExpression()}, {@link CfgVertex#isStatement|isStatement()}, {@link CfgVertex#isMarker|isMarker()}, {@link CfgVertex#isBlock|isBlock()} - for ways to check the type of a vertex against a specific type instead of getting the type and checking it against a specific type
+     * @see {@link CfgVertex#getId|getId()} - for a way to get the id of a vertex
+     * @see {@link CfgVertex#typeToString|typeToString()} - for a way to convert the type of a vertex to a string for easier debugging and visualization
+     */
+    readonly getType: (this: void, vertex: CfgVertex) => CfgVertexType;
+    /**
+     * Convert the given vertex type to a string for easier debugging and visualization.
+     * @see {@link CfgVertexType} - for the possible vertex types
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex and convert it to a string
+     */
+    readonly typeToString: (this: void, type: CfgVertexType) => string;
+    /**
+     * Get the id of the given vertex, which should directly relate to the AST node.
+     * @example
+     * ```ts
+     * const vertex: CfgVertex = CfgVertex.makeExpr('node-1')
+     * console.log(CfgVertex.getId(vertex)); // Output: 'node-1'
+     * ```
+     * @see {@link CfgVertex#getType|getType()} - for a way to get the type of a vertex
+     * @see {@link CfgVertex#getRootId|getRootId()} - for a way to get the root id of a vertex
+     */
+    readonly getId: <T extends CfgVertex | undefined>(this: void, vertex: T) => T extends undefined ? NodeId | undefined : NodeId;
+    /**
+     * Check whether two vertices are equal, i.e., they have the same type, id, and if they are basic block vertices, they also have the same elements in the same order.
+     */
+    readonly equal: (this: void, a: CfgVertex, b: CfgVertex) => boolean;
+    /**
+     * Get the root id of a vertex, i.e., the id of the AST node it corresponds to.
+     * For normal vertices, this is the same as the id of the vertex itself, for end marker vertices, this is the root id stored in the vertex.
+     * @see {@link CfgVertex#unpackRoot|unpackRoot()} - for a way to unpack the root id of a marker vertex
+     */
+    readonly getRootId: (this: void, vertex: CfgVertex) => NodeId;
+    /**
+     * Unpack the root id of a marker vertex, i.e., get the root id stored in the vertex or derive it from the canonical id if it is not explicitly stored.
+     * @see {@link CfgVertex#getRootId|getRootId()} - for a way to get the root id of a vertex, which uses this function for marker vertices
+     */
+    readonly unpackRootId: (this: void, vertex: CfgMarkerVertex) => NodeId;
+    /**
+     * Get the elements of a basic block vertex, i.e., the vertices that are part of this block, only connected by FDs, vertices should never occur in multiple bbs.
+     * @see {@link CfgVertex#isBlock|isBlock()} - for a way to check whether a vertex is a basic block vertex before trying to get the elements
+     * @see {@link CfgVertex#setBasicBlockElements|setBasicBlockElements()} - for a way to set the elements of a basic block vertex
+     */
+    readonly getBasicBlockElements: (this: void, vertex: CfgBasicBlockVertex) => readonly Exclude<CfgVertex, CfgBasicBlockVertex>[];
+    /**
+     * **Sets in-place**
+     * Set the elements of a basic block vertex, i.e., the vertices that are part of this block, only connected by FDs, vertices should never occur in multiple bbs.
+     * @see {@link CfgVertex#isBlock|isBlock()} - for a way to check whether a vertex is a basic block vertex before trying to set the elements
+     * @see {@link CfgVertex#getBasicBlockElements|getBasicBlockElements()} - for a way to get the elements of a basic block vertex
+     */
+    readonly setBasicBlockElements: (this: void, vertex: CfgBasicBlockVertex, elems: readonly Exclude<CfgVertex, CfgBasicBlockVertex>[]) => void;
+    /**
+     * Get the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers.
+     * @see {@link CfgVertex#getMid|getMid()} - for a way to get the ids of the mid-markers attached to this vertex
+     * @see {@link CfgVertex#setEnd|setEnd()} - for a way to set the ids of the end-markers attached to this vertex
+     */
+    readonly getEnd: (this: void, vertex: CfgVertex | undefined) => NodeId[] | undefined;
+    /**
+     * **Sets in-place**
+     * Set the ids of the end-markers attached to this vertex, which should directly relate to the AST nodes of the end markers.
+     * @see {@link CfgVertex#getEnd|getEnd()} - for a way to get the ids of the end-markers attached to this vertex
+     */
+    readonly setEnd: (this: void, vertex: CfgStatementVertex | CfgExpressionVertex, endMarkers: NodeId[] | undefined) => void;
+    /**
+     * Get the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers.
+     */
+    readonly getMid: (this: void, vertex: CfgVertex) => NodeId[] | undefined;
+    /**
+     * **Sets in-place**
+     * Set the ids of the mid-markers attached to this vertex, which should directly relate to the AST nodes of the mid markers.
+     * @see {@link CfgVertex#getMid|getMid()} - for a way to get the ids of the mid-markers attached to this vertex
+     * @see {@link CfgVertex#setEnd|setEnd()} - for a way to set the ids of the end-markers attached to this vertex
+     */
+    readonly setMid: (this: void, vertex: CfgStatementVertex | CfgExpressionVertex, midMarkers: NodeId[] | undefined) => void;
+    /**
+     * Converts the given id to a, canonical, basic block lift (i.e., it adds 'bb-' as a prefix).
+     */
+    readonly toBasicBlockId: <Id extends NodeId>(this: void, id: Id) => `bb-${Id}`;
+    /**
+     * Converts the given id to a canonical, end marker lift (i.e., it adds '-end' as a suffix).
+     * @see {@link CfgVertex#fromExitId|fromExitId()} - for a way to convert the given id from a canonical end marker lift to the original id (i.e., it removes '-end' as a suffix if it is present)
+     */
+    readonly toExitId: <Id extends NodeId>(this: void, id: Id) => `${Id}-e`;
+    /**
+     * Converts the given id from a canonical end marker lift to the original id (i.e., it removes '-end' as a suffix if it is present).
+     * @see {@link CfgVertex#toExitId|toExitId()} - for a way to convert the given id to a canonical end marker lift (i.e., it adds '-end' as a suffix)
+     */
+    readonly fromExitId: (this: void, exitId: NodeId) => NodeId;
+    /**
+     * Get the call targets of a statement or expression vertex, which links all targets of this call.
+     */
+    readonly getCallTargets: (this: void, vertex: CfgVertex | undefined) => Set<NodeId> | undefined;
+    /**
+     * **Sets in-place**
+     * Set the call targets of a statement or expression vertex, which links all targets of this call.
+     * @see {@link CfgVertex#getCallTargets|getCallTargets()} - for a way to get the call targets of a statement or expression vertex
+     * @see {@link CfgVertex#mapCallTargets|mapCallTargets()} - for a way to map the call targets of a statement or expression vertex to new call targets
+     */
+    readonly setCallTargets: (this: void, vertex: CfgStatementVertex | CfgExpressionVertex, callTargets: Set<NodeId>) => void;
+    /**
+     * Map the call targets of a statement or expression vertex, which links all targets of this call, to new call targets using the given mapping function.
+     * @see {@link CfgVertex#getCallTargets|getCallTargets()} - for a way to get the call targets of a statement or expression vertex
+     * @see {@link CfgVertex#setCallTargets|setCallTargets()} - for a way to set the call targets of a statement or expression vertex to new call targets
+     */
+    readonly mapCallTargets: (this: void, vertex: CfgStatementVertex | CfgExpressionVertex, mapFn: (targets: Set<NodeId> | undefined) => Set<NodeId>) => void;
+    /**
+     * Get the children of a statement or expression vertex, i.e., the child nodes attached to this one.
+     */
+    readonly getChildren: (this: void, vertex: CfgVertex | undefined) => NodeId[] | undefined;
+};
+type CfgFlowDependencyEdge = CfgEdgeType.Fd;
+type CfgControlDependencyEdge = [c: NodeId, w: typeof RTrue | typeof RFalse];
+/**
+ * An edge in the {@link ControlFlowGraph}.
+ * @see {@link CfgEdge} - for helper functions to work with edges.
  */
-export declare function getVertexRootId(vertex: CfgSimpleVertex): NodeId;
-interface CfgFlowDependencyEdge extends MergeableRecord {
-    label: CfgEdgeType.Fd;
-}
-export 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;
+/**
+ * Helper object for {@link CfgEdge} - an edge in the {@link ControlFlowGraph}.
+ */
+export declare const CfgEdge: {
+    /**
+     * Check whether the given edge is a flow dependency edge.
+     */
+    readonly isFlowDependency: (this: void, edge: CfgEdge | undefined) => edge is CfgFlowDependencyEdge;
+    /**
+     * Check whether the given edge is a control dependency edge.
+     */
+    readonly isControlDependency: (this: void, edge: CfgEdge | undefined) => edge is CfgControlDependencyEdge;
+    /**
+     * Create a flow dependency edge.
+     */
+    readonly makeFd: (this: void) => CfgFlowDependencyEdge;
+    /**
+     * Create a control dependency edge with the given cause and condition.
+     * @param controlId - the id of the vertex that causes the control dependency
+     * @param whenTrue  - whether the control dependency is satisfied with a true condition or is it negated (e.g., else-branch)
+     * @see {@link CfgEdge#makeCdTrue|makeCdTrue()} - for a version of this function that assumes the control dependency is satisfied with a true condition
+     * @see {@link CfgEdge#makeCdFalse|makeCdFalse()} - for a version of this function that assumes the control dependency is negated (e.g., else-branch)
+     */
+    readonly makeCd: (this: void, controlId: NodeId, whenTrue: typeof RTrue | typeof RFalse) => CfgControlDependencyEdge;
+    /**
+     * Create a control dependency edge with the given cause and a true condition.
+     * @param controlId - the id of the vertex that causes the control dependency
+     * @see {@link CfgEdge#makeCd|makeCd()} - for a version of this function that allows to specify the condition as well
+     */
+    readonly makeCdTrue: (this: void, controlId: NodeId) => CfgControlDependencyEdge;
+    /**
+     * Create a control dependency edge with the given cause and a negated condition (e.g., else-branch).
+     * @param controlId - the id of the vertex that causes the control dependency
+     * @see {@link CfgEdge#makeCd|makeCd()} - for a version of this function that allows to specify the condition as well
+     */
+    readonly makeCdFalse: (this: void, controlId: NodeId) => CfgControlDependencyEdge;
+    /**
+     * Get the cause of a control dependency edge, i.e., the id of the vertex that causes the control dependency.
+     * If the edge is not a control dependency edge, this returns undefined.
+     *
+     * This is the pendant of {@link CfgEdge#isControlDependency|isControlDependency()} on a {@link CfgEdge}.
+     * @see {@link CfgEdge#unpackCause|unpackCause()} - for a version of this function that assumes the edge is a control dependency edge and hence does not return undefined
+     */
+    readonly getCause: (this: void, edge: CfgEdge) => NodeId | undefined;
+    /**
+     * Get the cause of a control dependency edge, i.e., the id of the vertex that causes the control dependency.
+     */
+    readonly unpackCause: (this: void, edge: CfgControlDependencyEdge) => NodeId;
+    /**
+     * Get whether the control dependency edge is satisfied with a true condition or is it negated (e.g., else-branch).
+     * If the edge is not a control dependency edge, this returns undefined.
+     *
+     * This is the pendant of {@link CfgEdge#isControlDependency|isControlDependency()} on a {@link CfgEdge}.
+     * @see {@link CfgEdge#unpackWhen|unpackWhen()} - for a version of this function that assumes the edge is a control dependency edge and hence does not return undefined
+     */
+    readonly getWhen: (this: void, edge: CfgEdge) => typeof RTrue | typeof RFalse | undefined;
+    /**
+     * Get whether the control dependency edge is satisfied with a true condition or is it negated (e.g., else-branch).
+     */
+    readonly unpackWhen: (this: void, edge: CfgControlDependencyEdge) => typeof RTrue | typeof RFalse;
+    /**
+     * Check whether two edges are equal.
+     */
+    readonly equals: (this: void, a: CfgEdge, b: CfgEdge) => boolean;
+    /**
+     * Check whether the given edge is of the given type.
+     * @see {@link CfgEdge#getType|getType()} - for a version of this function that returns the type of the edge instead of checking against a given type
+     */
+    readonly isOfType: (this: void, edge: CfgEdge, type: CfgEdgeType) => boolean;
+    /**
+     * Get the type of the given edge.
+     * @see {@link CfgEdge#isOfType|isOfType()} - for a version of this function that checks whether the edge is of a given type
+     */
+    readonly getType: (this: void, edge: CfgEdge) => CfgEdgeType;
+    /**
+     * Provide a string representation of the given edge, e.g., for debugging or visualization purposes.
+     * @see {@link CfgEdge#toString|toString()} - for a version of this function that also includes the details of the edge (e.g., cause and condition for control dependency edges)
+     */
+    readonly typeToString: (this: void, edge: CfgEdge) => string;
+    /**
+     * Provide a string representation of the given edge, including its details (e.g., cause and condition for control dependency edges), e.g., for debugging or visualization purposes.
+     * @see {@link CfgEdge#typeToString|typeToString()} - for a version of this function that only includes the type of the edge
+     */
+    readonly toString: (this: void, edge: CfgEdge) => string;
+};
 /**
  * A read-only view of the {@link ControlFlowGraph}.
  */
@@ -108,7 +411,7 @@ export interface ReadOnlyControlFlowGraph {
      * @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>;
+    readonly vertices: (includeBasicBlockElements: boolean) => ReadonlyMap<NodeId, CfgVertex>;
     /**
      * 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()}.
@@ -137,7 +440,7 @@ export interface ReadOnlyControlFlowGraph {
      *
      * This is the pendant of {@link DataflowGraph#getVertex|getVertex()} on a {@link DataflowGraph}.
      */
-    readonly getVertex: (id: NodeId, includeBlocks?: boolean) => CfgSimpleVertex | undefined;
+    readonly getVertex: (id: NodeId, includeBlocks?: boolean) => CfgVertex | undefined;
     /**
      * Check if a vertex with the given id exists in the graph.
      * @param id - the id of the vertex to check
@@ -158,7 +461,7 @@ export interface ReadOnlyControlFlowGraph {
 }
 /**
  * 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()}).
+ * The control flow may be hierarchical when confronted with function definitions (see {@link CfgVertex} 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
@@ -166,18 +469,18 @@ export interface ReadOnlyControlFlowGraph {
  *
  * 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;
+export declare class ControlFlowGraph<Vertex extends CfgVertex = CfgVertex> implements ReadOnlyControlFlowGraph {
+    private readonly roots;
     /** Nesting-Independent vertex information, mapping the id to the vertex */
-    private readonly vertexInformation;
+    private readonly vtxInfos;
     /** 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;
+    private readonly edgeInfos;
     /** reverse edges for bidirectional mapping */
-    private readonly reverseEdgeInfo;
+    private readonly revEdgeInfos;
     /** used as an optimization to avoid unnecessary lookups */
-    private _mayHaveBasicBlocks;
+    private _mayBB;
     /**
      * Add a new vertex to the control flow graph.
      * @see {@link ControlFlowGraph#addEdge|addEdge()} - to add an edge
@@ -196,13 +499,13 @@ export declare class ControlFlowGraph<Vertex extends CfgSimpleVertex = CfgSimple
     outgoingEdges(node: NodeId): ReadonlyMap<NodeId, CfgEdge> | undefined;
     ingoingEdges(node: NodeId): ReadonlyMap<NodeId, CfgEdge> | undefined;
     rootIds(): ReadonlySet<NodeId>;
-    vertices(includeBasicBlockElements?: boolean): ReadonlyMap<NodeId, CfgSimpleVertex>;
+    vertices(includeBasicBlockElements?: boolean): ReadonlyMap<NodeId, CfgVertex>;
     getBasicBlock(elemId: NodeId): CfgBasicBlockVertex | undefined;
     edges(): ReadonlyMap<NodeId, ReadonlyMap<NodeId, CfgEdge>>;
     /**
      * Retrieve a vertex by its id.
      */
-    getVertex(id: NodeId, includeBlocks?: boolean): CfgSimpleVertex | undefined;
+    getVertex(id: NodeId, includeBlocks?: boolean): CfgVertex | undefined;
     hasVertex(id: NodeId, includeBlocks?: boolean): boolean;
     mayHaveBasicBlocks(): boolean;
     /**
@@ -221,6 +524,7 @@ export declare class ControlFlowGraph<Vertex extends CfgSimpleVertex = CfgSimple
     /** merges b into a */
     mergeTwoBasicBlocks(a: NodeId, b: NodeId): this;
     /**
+     * **This Operation is in-place and modifies the current graph.**
      * 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).
@@ -233,7 +537,7 @@ export declare class ControlFlowGraph<Vertex extends CfgSimpleVertex = CfgSimple
  * Summarizes the control information of a program
  * @see {@link emptyControlFlowInformation} - to create an empty control flow information object
  */
-export interface ControlFlowInformation<Vertex extends CfgSimpleVertex = CfgSimpleVertex> extends MergeableRecord {
+export interface ControlFlowInformation<Vertex extends CfgVertex = CfgVertex> extends MergeableRecord {
     /** all active 'return'(-like) unconditional jumps */
     returns: NodeId[];
     /** all active 'break'(-like) unconditional jumps */