@eagleoutice/flowr 1.3.11

package/dataflow/graph/diff.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffEdges = exports.diffVertices = exports.diffFunctionArguments = exports.equalFunctionArguments = exports.equalExitPoints = exports.diffOfDataflowGraphs = void 0;
+const environments_1 = require("../environments");
+const assert_1 = require("../../util/assert");
+const diff_1 = require("../../util/diff");
+const json_1 = require("../../util/json");
+class DataflowDifferenceReport {
+    _comments = undefined;
+    addComment(comment) {
+        if (this._comments === undefined) {
+            this._comments = [comment];
+        }
+        else {
+            this._comments.push(comment);
+        }
+    }
+    comments() {
+        return this._comments;
+    }
+    isEqual() {
+        return this._comments === undefined;
+    }
+}
+function initDiffContext(left, right) {
+    return {
+        left: left.graph,
+        leftname: left.name,
+        right: right.graph,
+        rightname: right.name,
+        report: new DataflowDifferenceReport(),
+        position: ''
+    };
+}
+function diff(ctx) {
+    diffRootVertices(ctx);
+    diffVertices(ctx);
+    diffOutgoingEdges(ctx);
+    return true;
+}
+function diffOutgoingEdges(ctx) {
+    const lEdges = new Map(ctx.left.edges());
+    const rEdges = new Map(ctx.right.edges());
+    if (lEdges.size !== rEdges.size) {
+        ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size}, ${ctx.rightname} has ${rEdges.size}`);
+    }
+    for (const [id, edge] of lEdges) {
+        diffEdges(ctx, id, edge, rEdges.get(id));
+    }
+}
+function diffRootVertices(ctx) {
+    (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
+}
+function diffOfDataflowGraphs(left, right) {
+    if (left.graph === right.graph) {
+        return new DataflowDifferenceReport();
+    }
+    const ctx = initDiffContext(left, right);
+    diff(ctx);
+    return ctx.report;
+}
+exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
+function diffFunctionArgumentsReferences(a, b, ctx) {
+    if (a === '<value>' || b === '<value>') {
+        if (a !== b) {
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    (0, environments_1.diffIdentifierReferences)(a, b, ctx);
+}
+function equalExitPoints(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalExitPoints = equalExitPoints;
+function equalFunctionArguments(a, b) {
+    const ctx = {
+        report: new DataflowDifferenceReport(),
+        leftname: 'left',
+        rightname: 'right',
+        position: ''
+    };
+    diffFunctionArguments(a, b, ctx);
+    return ctx.report.isEqual();
+}
+exports.equalFunctionArguments = equalFunctionArguments;
+function diffFunctionArguments(a, b, ctx) {
+    if (a === false || b === false) {
+        if (a !== b) {
+            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    else if (a.length !== b.length) {
+        ctx.report.addComment(`${ctx.position}Differs in number of arguments. ${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
+        return;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        const aArg = a[i];
+        const bArg = b[i];
+        if (Array.isArray(aArg) && Array.isArray(bArg)) {
+            // must have same name
+            if (aArg[0] !== bArg[0]) {
+                ctx.report.addComment(`${ctx.position}In the ${i}th argument (of ${ctx.leftname}, named) the name differs: ${aArg[0]} vs ${bArg[0]}.`);
+                continue;
+            }
+            diffFunctionArgumentsReferences(aArg[1], bArg[1], {
+                ...ctx,
+                position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, named). `
+            });
+        }
+        else {
+            diffFunctionArgumentsReferences(aArg, bArg, { ...ctx, position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, unnamed).` });
+        }
+    }
+}
+exports.diffFunctionArguments = diffFunctionArguments;
+function diffVertices(ctx) {
+    // collect vertices from both sides
+    const lVert = [...ctx.left.vertices(true)];
+    const rVert = [...ctx.right.vertices(true)];
+    if (lVert.length !== rVert.length) {
+        ctx.report.addComment(`Detected different number of vertices! ${ctx.leftname} has ${lVert.length}, ${ctx.rightname} has ${rVert.length}`);
+    }
+    for (const [id, lInfo] of lVert) {
+        const rInfoMay = ctx.right.get(id);
+        if (rInfoMay === undefined) {
+            ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`);
+            continue;
+        }
+        const [rInfo] = rInfoMay;
+        if (lInfo.tag !== rInfo.tag) {
+            ctx.report.addComment(`Vertex ${id} has different tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
+        }
+        if (lInfo.name !== rInfo.name) {
+            ctx.report.addComment(`Vertex ${id} has different names. ${ctx.leftname}: ${lInfo.name} vs ${ctx.rightname}: ${rInfo.name}`);
+        }
+        if (lInfo.tag === 'variable-definition' || lInfo.tag === 'function-definition') {
+            (0, assert_1.guard)(lInfo.tag === rInfo.tag, () => `node ${id} does not match on tag (${lInfo.tag} vs ${rInfo.tag})`);
+            if (lInfo.scope !== rInfo.scope) {
+                ctx.report.addComment(`Vertex ${id} has different scopes. ${ctx.leftname}: ${lInfo.scope} vs ${ctx.rightname}: ${rInfo.scope}`);
+            }
+        }
+        if (lInfo.when !== rInfo.when) {
+            ctx.report.addComment(`Vertex ${id} has different when. ${ctx.leftname}: ${lInfo.when} vs ${ctx.rightname}: ${rInfo.when}`);
+        }
+        (0, environments_1.diffEnvironments)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environments. ` });
+        if (lInfo.tag === 'function-call') {
+            (0, assert_1.guard)(rInfo.tag === 'function-call', 'otherInfo must be a function call as well');
+            diffFunctionArguments(lInfo.args, rInfo.args, { ...ctx, position: `${ctx.position}Vertex ${id} (function call) differs in arguments. ` });
+        }
+        if (lInfo.tag === 'function-definition') {
+            (0, assert_1.guard)(rInfo.tag === 'function-definition', 'otherInfo must be a function definition as well');
+            if (!equalExitPoints(lInfo.exitPoints, rInfo.exitPoints)) {
+                ctx.report.addComment(`Vertex ${id} has different exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`);
+            }
+            if (lInfo.subflow.scope !== rInfo.subflow.scope) {
+                ctx.report.addComment(`Vertex ${id} has different subflow scope. ${ctx.leftname}: ${JSON.stringify(lInfo.subflow, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.subflow, json_1.jsonReplacer)}`);
+            }
+            (0, environments_1.diffEnvironments)(lInfo.subflow.environments, rInfo.subflow.environments, { ...ctx, position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. ` });
+            (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, { ...ctx, position: `${ctx.position}Vertex ${id} differs in subflow graph. ` });
+        }
+    }
+}
+exports.diffVertices = diffVertices;
+function diffEdges(ctx, id, lEdges, rEdges) {
+    if (lEdges === undefined || rEdges === undefined) {
+        if (lEdges !== rEdges) {
+            ctx.report.addComment(`Vertex ${id} has undefined outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
+        }
+        return;
+    }
+    if (lEdges.size !== rEdges.size) {
+        ctx.report.addComment(`Vertex ${id} has different number of outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
+    }
+    // order independent compare
+    for (const [target, edge] of lEdges) {
+        const otherEdge = rEdges.get(target);
+        if (otherEdge === undefined) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`);
+            continue;
+        }
+        if (edge.types.size !== otherEdge.types.size) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different number of edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
+        }
+        if ([...edge.types].some(e => !otherEdge.types.has(e))) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
+        }
+        if (edge.attribute !== otherEdge.attribute) {
+            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different attributes: ${JSON.stringify(edge.attribute)} vs ${JSON.stringify(otherEdge.attribute)}`);
+        }
+    }
+}
+exports.diffEdges = diffEdges;
+//# sourceMappingURL=diff.js.map

package/dataflow/graph/edge.d.ts

@@ -0,0 +1,37 @@
+/**
+ * An edge consist of the target node (i.e., the variable or processing node),
+ * a type (if it is read or used in the context), and an attribute (if this edge exists for every program execution or
+ * if it is only one possible execution path).
+ */
+export interface DataflowGraphEdge {
+    types: Set<EdgeType>;
+    attribute: DataflowGraphEdgeAttribute;
+}
+export type DataflowGraphEdgeAttribute = 'always' | 'maybe';
+/**
+ * Represents the relationship between the source and the target vertex in the dataflow graph.
+ */
+export declare enum EdgeType {
+    /** The edge determines that source reads target */
+    Reads = "reads",
+    /** The edge determines that source is defined by target */
+    DefinedBy = "defined-by",
+    /** The edge determines that both nodes reference the same variable in a lexical/scoping sense, source and target are interchangeable (reads for at construction unbound variables) */
+    SameReadRead = "same-read-read",
+    /** Similar to `same-read-read` but for def-def constructs without a read in-between */
+    SameDefDef = "same-def-def",
+    /** The edge determines that the source calls the target */
+    Calls = "calls",
+    /** The source returns target on call */
+    Returns = "returns",
+    /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
+    DefinesOnCall = "defines-on-call",
+    /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
+    DefinedByOnCall = "defined-by-on-call",
+    /** Formal used as argument to a function call */
+    Argument = "argument",
+    /** The edge determines that the source is a side effect that happens when the target is called */
+    SideEffectOnCall = "side-effect-on-call",
+    /** The source and edge relate to each other bidirectionally */
+    Relates = "relates"
+}

package/dataflow/graph/edge.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeType = void 0;
+/**
+ * Represents the relationship between the source and the target vertex in the dataflow graph.
+ */
+var EdgeType;
+(function (EdgeType) {
+    /** The edge determines that source reads target */
+    EdgeType["Reads"] = "reads";
+    /** The edge determines that source is defined by target */
+    EdgeType["DefinedBy"] = "defined-by";
+    /** The edge determines that both nodes reference the same variable in a lexical/scoping sense, source and target are interchangeable (reads for at construction unbound variables) */
+    EdgeType["SameReadRead"] = "same-read-read";
+    /** Similar to `same-read-read` but for def-def constructs without a read in-between */
+    EdgeType["SameDefDef"] = "same-def-def";
+    /** The edge determines that the source calls the target */
+    EdgeType["Calls"] = "calls";
+    /** The source returns target on call */
+    EdgeType["Returns"] = "returns";
+    /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
+    EdgeType["DefinesOnCall"] = "defines-on-call";
+    /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
+    EdgeType["DefinedByOnCall"] = "defined-by-on-call";
+    /** Formal used as argument to a function call */
+    EdgeType["Argument"] = "argument";
+    /** The edge determines that the source is a side effect that happens when the target is called */
+    EdgeType["SideEffectOnCall"] = "side-effect-on-call";
+    /** The source and edge relate to each other bidirectionally */
+    EdgeType["Relates"] = "relates";
+})(EdgeType || (exports.EdgeType = EdgeType = {}));
+//# sourceMappingURL=edge.js.map

package/dataflow/graph/equal.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalEdges = exports.equalVertices = exports.equalFunctionArguments = exports.equalExitPoints = void 0;
+const environments_1 = require("../environments");
+const index_1 = require("../index");
+const assert_1 = require("../../util/assert");
+const json_1 = require("../../util/json");
+const set_1 = require("../../util/set");
+function equalFunctionArgumentsReferences(a, b) {
+    if (a === '<value>' || b === '<value>') {
+        return a === b;
+    }
+    return (0, environments_1.equalIdentifierReferences)(a, b);
+}
+function equalExitPoints(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalExitPoints = equalExitPoints;
+function equalFunctionArguments(a, b) {
+    if (a === false || b === false) {
+        return a === b;
+    }
+    else if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        const aArg = a[i];
+        const bArg = b[i];
+        if (Array.isArray(aArg) && Array.isArray(bArg)) {
+            // must have same name
+            if (aArg[0] !== bArg[0]) {
+                return false;
+            }
+            if (!equalFunctionArgumentsReferences(aArg[1], bArg[1])) {
+                return false;
+            }
+        }
+        else if (!equalFunctionArgumentsReferences(aArg, bArg)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalFunctionArguments = equalFunctionArguments;
+function equalVertices(our, other) {
+    if (our.size !== other.size) {
+        index_1.dataflowLogger.warn(`graph size does not match: ${our.size} vs ${other.size}`);
+        return false;
+    }
+    for (const [id, info] of our) {
+        const otherInfo = other.get(id);
+        if (otherInfo === undefined || info.tag !== otherInfo.tag || info.name !== otherInfo.name) {
+            index_1.dataflowLogger.warn(`node ${id} does not match (${JSON.stringify(info)} vs ${JSON.stringify(otherInfo)})`);
+            return false;
+        }
+        if (info.tag === 'variable-definition' || info.tag === 'function-definition') {
+            (0, assert_1.guard)(info.tag === otherInfo.tag, () => `node ${id} does not match on tag (${info.tag} vs ${otherInfo.tag})`);
+            if (info.scope !== otherInfo.scope) {
+                index_1.dataflowLogger.warn(`node ${id} does not match on scope (${JSON.stringify(info.scope)} vs ${JSON.stringify(otherInfo.scope)})`);
+                return false;
+            }
+        }
+        if (info.when !== otherInfo.when) {
+            index_1.dataflowLogger.warn(`node ${id} does not match on when (${JSON.stringify(info.when)} vs ${JSON.stringify(otherInfo.when)})`);
+            return false;
+        }
+        if (!(0, environments_1.environmentsEqual)(info.environment, otherInfo.environment)) {
+            index_1.dataflowLogger.warn(`node ${id} does not match on environments (${JSON.stringify(info.environment)} vs ${JSON.stringify(otherInfo.environment)})`);
+            return false;
+        }
+        if (info.tag === 'function-call') {
+            (0, assert_1.guard)(otherInfo.tag === 'function-call', 'otherInfo must be a function call as well');
+            if (!equalFunctionArguments(info.args, otherInfo.args)) {
+                index_1.dataflowLogger.warn(`node ${id} does not match on function arguments (${JSON.stringify(info.args)} vs ${JSON.stringify(otherInfo.args)})`);
+                return false;
+            }
+        }
+        if (info.tag === 'function-definition') {
+            (0, assert_1.guard)(otherInfo.tag === 'function-definition', 'otherInfo must be a function definition as well');
+            if (!equalExitPoints(info.exitPoints, otherInfo.exitPoints)) {
+                index_1.dataflowLogger.warn(`node ${id} does not match on exit points (${JSON.stringify(info.exitPoints)} vs ${JSON.stringify(otherInfo.exitPoints)})`);
+                return false;
+            }
+            if (info.subflow.scope !== otherInfo.subflow.scope || !(0, environments_1.environmentsEqual)(info.subflow.environments, otherInfo.subflow.environments)) {
+                index_1.dataflowLogger.warn(`node ${id} does not match on subflow (${JSON.stringify(info)} vs ${JSON.stringify(otherInfo)})`);
+                return false;
+            }
+            if (!(0, set_1.setEquals)(info.subflow.graph, otherInfo.subflow.graph)) {
+                index_1.dataflowLogger.warn(`node ${id} does not match on subflow graph (${JSON.stringify(info)} vs ${JSON.stringify(otherInfo)})`);
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.equalVertices = equalVertices;
+function equalEdges(id, our, other) {
+    if (our === undefined || other === undefined) {
+        return our === other;
+    }
+    if (our.size !== other.size) {
+        index_1.dataflowLogger.warn(`total edge size for ${id} does not match: ${our.size} vs ${other.size} (${JSON.stringify(our, json_1.jsonReplacer)}, ${JSON.stringify(other, json_1.jsonReplacer)})`);
+        return false;
+    }
+    // order independent compare
+    for (const [target, edge] of our) {
+        const otherEdge = other.get(target);
+        if (otherEdge === undefined || edge.types.size !== otherEdge.types.size || [...edge.types].some(e => !otherEdge.types.has(e)) || edge.attribute !== otherEdge.attribute) {
+            index_1.dataflowLogger.warn(`edge with ${id}->${target} does not match (${JSON.stringify(edge, json_1.jsonReplacer)} vs ${JSON.stringify(otherEdge, json_1.jsonReplacer)})`);
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalEdges = equalEdges;
+//# sourceMappingURL=equal.js.map

package/dataflow/graph/graph.d.ts

@@ -0,0 +1,120 @@
+import { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
+import { IdentifierDefinition, IdentifierReference } from '../environments';
+import { BiMap } from '../../util/bimap';
+import { DataflowGraphEdge, DataflowGraphEdgeAttribute, EdgeType } from './edge';
+import { DataflowInformation } from '../internal/info';
+import { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
+import { DifferenceReport } from '../../util/diff';
+/** Used to get an entry point for every id, after that it allows reference-chasing of the graph */
+export type DataflowMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
+export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'> & {
+    graph: Set<NodeId>;
+};
+export type NamedFunctionArgument = [string, IdentifierReference | '<value>'];
+export type PositionalFunctionArgument = IdentifierReference | '<value>';
+export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | 'empty';
+type ReferenceForEdge = Pick<IdentifierReference, 'nodeId' | 'used'> | IdentifierDefinition;
+/**
+ * Maps the edges target to the edge information
+ */
+export type OutgoingEdges = Map<NodeId, DataflowGraphEdge>;
+/**
+ * Similar to {@link OutgoingEdges}, but inverted regarding the edge direction.
+ * In other words, it maps the source to the edge information.
+ */
+export type IngoingEdges = Map<NodeId, DataflowGraphEdge>;
+/**
+ * The dataflow graph holds the dataflow information found within the given AST.
+ * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
+ *
+ * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
+ * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.
+ * After the dataflow analysis, all sources and targets of the edges *must* be part of the vertices.
+ * However, this does not have to hold during the construction as edges may point from or to vertices which are yet to be constructed.
+ *
+ * All methods return the modified graph to allow for chaining.
+ */
+export declare class DataflowGraph {
+    private static DEFAULT_ENVIRONMENT;
+    /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
+    private rootVertices;
+    /** All vertices in the complete graph (including those nested in function definition) */
+    private vertexInformation;
+    /** All edges in the complete graph (including those nested in function definition) */
+    private edgeInformation;
+    /**
+     * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
+     *
+     * @param id                      - The id of the node to get
+     * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
+     * @returns the node info for the given id (if it exists)
+     */
+    get(id: NodeId, includeDefinedFunctions?: boolean): [DataflowGraphVertexInfo, OutgoingEdges] | undefined;
+    outgoingEdges(id: NodeId): OutgoingEdges | undefined;
+    ingoingEdges(id: NodeId): IngoingEdges | undefined;
+    /**
+   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     *
+     * @see #edges
+   */
+    vertices(includeDefinedFunctions: boolean): IterableIterator<[NodeId, DataflowGraphVertexInfo]>;
+    /**
+     * @returns the ids of all edges in the graph together with their edge information
+     *
+     * @see #vertices
+     */
+    edges(): IterableIterator<[NodeId, OutgoingEdges]>;
+    /**
+     * Returns true if the graph contains a node with the given id.
+     *
+     * @param id                      - The id to check for
+     * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
+     */
+    hasNode(id: NodeId, includeDefinedFunctions: boolean): boolean;
+    /**
+     * Returns true if the root level of the graph contains a node with the given id.
+     */
+    isRoot(id: NodeId): boolean;
+    rootIds(): ReadonlySet<NodeId>;
+    /**
+   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
+   *
+     * @param vertex - The vertex to add
+     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds | root vertices} of the graph.
+     *                 This is probably only of use, when you construct dataflow graphs for tests.
+     *
+   * @see DataflowGraphVertexInfo
+   * @see DataflowGraphVertexArgument
+   */
+    addVertex(vertex: DataflowGraphVertexArgument, asRoot?: boolean): this;
+    /** Basically only exists for creations in tests, within the dataflow-extraction, this 3-argument variant will determine `attribute` automatically */
+    addEdge(from: NodeId, to: NodeId, type: EdgeType, attribute: DataflowGraphEdgeAttribute): this;
+    /** {@inheritDoc} */
+    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, type: EdgeType): this;
+    /** {@inheritDoc} */
+    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, type: EdgeType, attribute?: DataflowGraphEdgeAttribute, promote?: boolean): this;
+    /**
+     * Merges the other graph into *this* one (in-place). The return value is only for convenience.
+     *
+     * @param otherGraph        - The graph to merge into this one
+     * @param mergeRootVertices - If false, this will only merge the vertices and edges but exclude the root vertices this is probably only of use
+     * 													  in the context of function definitions
+     */
+    mergeWith(otherGraph: DataflowGraph | undefined, mergeRootVertices?: boolean): this;
+    private mergeEdges;
+    equals(other: DataflowGraph, diff: true, names?: {
+        left: string;
+        right: string;
+    }): DifferenceReport;
+    equals(other: DataflowGraph, diff?: false, names?: {
+        left: string;
+        right: string;
+    }): boolean;
+    /**
+     * Marks a vertex in the graph to be a definition
+     * @param reference - The reference to the vertex to mark as definition
+     */
+    setDefinitionOfVertex(reference: IdentifierReference): void;
+}
+export {};