@eagleoutice/flowr 2.0.25 → 2.1.0

package/dataflow/graph/dataflowgraph-builder.d.ts

@@ -0,0 +1,139 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
+import { DataflowGraph } from './graph';
+import type { REnvironmentInformation } from '../environments/environment';
+import type { DataflowGraphVertexUse } from './vertex';
+import type { ControlDependency } from '../info';
+export declare function emptyGraph(idMap?: AstIdMap): DataflowGraphBuilder;
+export type DataflowGraphEdgeTarget = NodeId | (readonly NodeId[]);
+/**
+ * This DataflowGraphBuilder extends {@link DataflowGraph} with builder methods to
+ * easily and compactly add vertices and edges to a dataflow graph. Its usage thus
+ * simplifies writing tests for dataflow graphs.
+ */
+export declare class DataflowGraphBuilder extends DataflowGraph {
+    /**
+     * Adds a **vertex** for a **function definition** (V1).
+     *
+     * @param id - AST node ID
+     * @param subflow - Subflow data graph for the defined function.
+     * @param exitPoints - Node IDs for exit point vertices.
+     * @param info - Additional/optional properties.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    defineFunction(id: NodeId, exitPoints: readonly NodeId[], subflow: DataflowFunctionFlowInformation, info?: {
+        environment?: REnvironmentInformation;
+        controlDependencies?: ControlDependency[];
+    }, asRoot?: boolean): this;
+    /**
+     * Adds a **vertex** for a **function call** (V2).
+     *
+     * @param id - AST node ID
+     * @param name - Function name
+     * @param args - Function arguments; may be empty
+     * @param info - Additional/optional properties.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    call(id: NodeId, name: string, args: FunctionArgument[], info?: {
+        returns?: readonly NodeId[];
+        reads?: readonly NodeId[];
+        onlyBuiltIn?: boolean;
+        environment?: REnvironmentInformation;
+        controlDependencies?: ControlDependency[];
+    }, asRoot?: boolean): this;
+    /** automatically adds argument links if they do not already exist */
+    private addArgumentLinks;
+    /**
+     * Adds a **vertex** for a **variable definition** (V4).
+     *
+     * @param id - AST node ID
+     * @param name - Variable name
+     * @param info - Additional/optional properties.
+     * @param asRoot - Should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    defineVariable(id: NodeId, name?: string, info?: {
+        controlDependencies?: ControlDependency[];
+        definedBy?: NodeId[];
+    }, asRoot?: boolean): this;
+    /**
+     * Adds a **vertex** for **variable use** (V5). Intended for creating dataflow graphs as part of function tests.
+     *
+     * @param id - AST node id
+     * @param name - Variable name
+     * @param info - Additional/optional properties; i.e., scope, when, or environment.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point) or is it nested (e.g., as part of a function definition)
+     */
+    use(id: NodeId, name?: string, info?: Partial<DataflowGraphVertexUse>, asRoot?: boolean): this;
+    /**
+     * Adds a **vertex** for a **constant value** (V6).
+     *
+     * @param id - AST node ID
+     * @param options - Additional/optional properties;
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    constant(id: NodeId, options?: {
+        controlDependencies?: ControlDependency[];
+    }, asRoot?: boolean): this;
+    private edgeHelper;
+    /**
+     * Adds a **read edge** (E1).
+     *
+     * @param from - Vertex/NodeId
+     * @param to   - see from
+     */
+    reads(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **defined-by edge** (E2), with from as defined variable, and to
+     * as a variable/function contributing to its definition.
+     *
+     * @see reads for parameters.
+     */
+    definedBy(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **call edge** (E5) with from as caller, and to as callee.
+     *
+     * @see reads for parameters.
+     */
+    calls(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **return edge** (E6) with from as function, and to as exit point.
+     *
+     * @see reads for parameters.
+     */
+    returns(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **defines-on-call edge** (E7) with from as variable, and to as its definition
+     *
+     * @see reads for parameters.
+     */
+    definesOnCall(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds an **argument edge** (E9) with from as function call, and to as argument.
+     *
+     * @see reads for parameters.
+     */
+    argument(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **non-standard evaluation edge** with from as vertex, and to as vertex.
+     *
+     * @see reads for parameters.
+     */
+    nse(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **side-effect-on-call edge** with from as vertex, and to as vertex.
+     *
+     * @see reads for parameters.
+     */
+    sideEffectOnCall(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * explicitly overwrite the root ids of the graph,
+     * this is just an easier variant in case you working with a lot of functions this saves you a lot of `false` flags.
+     */
+    overwriteRootIds(ids: readonly NodeId[]): this;
+}

package/dataflow/graph/dataflowgraph-builder.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowGraphBuilder = void 0;
+exports.emptyGraph = emptyGraph;
+const objects_1 = require("../../util/objects");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const graph_1 = require("./graph");
+const environment_1 = require("../environments/environment");
+const vertex_1 = require("./vertex");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const built_in_1 = require("../environments/built-in");
+const edge_1 = require("./edge");
+function emptyGraph(idMap) {
+    return new DataflowGraphBuilder(idMap);
+}
+/**
+ * This DataflowGraphBuilder extends {@link DataflowGraph} with builder methods to
+ * easily and compactly add vertices and edges to a dataflow graph. Its usage thus
+ * simplifies writing tests for dataflow graphs.
+ */
+class DataflowGraphBuilder extends graph_1.DataflowGraph {
+    /**
+     * Adds a **vertex** for a **function definition** (V1).
+     *
+     * @param id - AST node ID
+     * @param subflow - Subflow data graph for the defined function.
+     * @param exitPoints - Node IDs for exit point vertices.
+     * @param info - Additional/optional properties.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    defineFunction(id, exitPoints, subflow, info, asRoot = true) {
+        return this.addVertex({
+            tag: vertex_1.VertexType.FunctionDefinition,
+            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            subflow: {
+                ...subflow,
+                entryPoint: (0, node_id_1.normalizeIdToNumberIfPossible)(subflow.entryPoint),
+                graph: new Set([...subflow.graph].map(node_id_1.normalizeIdToNumberIfPossible)),
+                out: subflow.out.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                in: subflow.in.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }))
+            },
+            exitPoints: exitPoints.map(node_id_1.normalizeIdToNumberIfPossible),
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            environment: info?.environment
+        }, asRoot);
+    }
+    /**
+     * Adds a **vertex** for a **function call** (V2).
+     *
+     * @param id - AST node ID
+     * @param name - Function name
+     * @param args - Function arguments; may be empty
+     * @param info - Additional/optional properties.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    call(id, name, args, info, asRoot = true) {
+        const onlyBuiltInAuto = info?.reads?.length === 1 && info?.reads[0] === built_in_1.BuiltIn;
+        this.addVertex({
+            tag: vertex_1.VertexType.FunctionCall,
+            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            name,
+            args: args.map(a => a === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : { ...a, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(a.nodeId), controlDependencies: undefined }),
+            environment: (info?.onlyBuiltIn || onlyBuiltInAuto) ? undefined : info?.environment ?? (0, environment_1.initializeCleanEnvironments)(),
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            onlyBuiltin: info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false
+        }, asRoot);
+        this.addArgumentLinks(id, args);
+        if (info?.returns) {
+            for (const ret of info.returns) {
+                this.returns(id, ret);
+            }
+        }
+        if (info?.reads) {
+            for (const call of info.reads) {
+                this.reads(id, call);
+            }
+        }
+        return this;
+    }
+    /** automatically adds argument links if they do not already exist */
+    addArgumentLinks(id, args) {
+        for (const arg of args) {
+            if (arg === r_function_call_1.EmptyArgument) {
+                continue;
+            }
+            if ((0, graph_1.isPositionalArgument)(arg)) {
+                this.argument(id, arg.nodeId);
+                if (typeof arg.nodeId === 'string' && arg.nodeId.endsWith('-arg')) {
+                    const withoutSuffix = arg.nodeId.slice(0, -4);
+                    this.reads(arg.nodeId, withoutSuffix);
+                }
+            }
+            else if (!this.hasVertex(arg.nodeId, true)) {
+                this.use(arg.nodeId, arg.name, { controlDependencies: arg.controlDependencies });
+                this.argument(id, arg.nodeId);
+            }
+        }
+    }
+    /**
+     * Adds a **vertex** for a **variable definition** (V4).
+     *
+     * @param id - AST node ID
+     * @param name - Variable name
+     * @param info - Additional/optional properties.
+     * @param asRoot - Should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    defineVariable(id, name, info, asRoot = true) {
+        this.addVertex({
+            tag: vertex_1.VertexType.VariableDefinition,
+            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            name,
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+        }, asRoot);
+        if (info?.definedBy) {
+            for (const def of info.definedBy) {
+                this.definedBy(id, def);
+            }
+        }
+        return this;
+    }
+    /**
+     * Adds a **vertex** for **variable use** (V5). Intended for creating dataflow graphs as part of function tests.
+     *
+     * @param id - AST node id
+     * @param name - Variable name
+     * @param info - Additional/optional properties; i.e., scope, when, or environment.
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point) or is it nested (e.g., as part of a function definition)
+     */
+    use(id, name, info, asRoot = true) {
+        return this.addVertex((0, objects_1.deepMergeObject)({
+            tag: vertex_1.VertexType.Use,
+            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            name,
+            controlDependencies: undefined,
+            environment: undefined
+        }, {
+            ...info,
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
+        }), asRoot);
+    }
+    /**
+     * Adds a **vertex** for a **constant value** (V6).
+     *
+     * @param id - AST node ID
+     * @param options - Additional/optional properties;
+     * @param asRoot - should the vertex be part of the root vertex set of the graph
+     * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
+     */
+    constant(id, options, asRoot = true) {
+        return this.addVertex({
+            tag: vertex_1.VertexType.Value,
+            id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            controlDependencies: options?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            environment: undefined
+        }, asRoot);
+    }
+    edgeHelper(from, to, type) {
+        if (Array.isArray(to)) {
+            for (const t of to) {
+                this.edgeHelper(from, t, type);
+            }
+            return this;
+        }
+        return this.addEdge((0, node_id_1.normalizeIdToNumberIfPossible)(from), (0, node_id_1.normalizeIdToNumberIfPossible)(to), type);
+    }
+    /**
+     * Adds a **read edge** (E1).
+     *
+     * @param from - Vertex/NodeId
+     * @param to   - see from
+     */
+    reads(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.Reads);
+    }
+    /**
+     * Adds a **defined-by edge** (E2), with from as defined variable, and to
+     * as a variable/function contributing to its definition.
+     *
+     * @see reads for parameters.
+     */
+    definedBy(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.DefinedBy);
+    }
+    /**
+     * Adds a **call edge** (E5) with from as caller, and to as callee.
+     *
+     * @see reads for parameters.
+     */
+    calls(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.Calls);
+    }
+    /**
+     * Adds a **return edge** (E6) with from as function, and to as exit point.
+     *
+     * @see reads for parameters.
+     */
+    returns(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.Returns);
+    }
+    /**
+     * Adds a **defines-on-call edge** (E7) with from as variable, and to as its definition
+     *
+     * @see reads for parameters.
+     */
+    definesOnCall(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.DefinesOnCall);
+    }
+    /**
+     * Adds an **argument edge** (E9) with from as function call, and to as argument.
+     *
+     * @see reads for parameters.
+     */
+    argument(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.Argument);
+    }
+    /**
+     * Adds a **non-standard evaluation edge** with from as vertex, and to as vertex.
+     *
+     * @see reads for parameters.
+     */
+    nse(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.NonStandardEvaluation);
+    }
+    /**
+     * Adds a **side-effect-on-call edge** with from as vertex, and to as vertex.
+     *
+     * @see reads for parameters.
+     */
+    sideEffectOnCall(from, to) {
+        return this.edgeHelper(from, to, edge_1.EdgeType.SideEffectOnCall);
+    }
+    /**
+     * explicitly overwrite the root ids of the graph,
+     * this is just an easier variant in case you working with a lot of functions this saves you a lot of `false` flags.
+     */
+    overwriteRootIds(ids) {
+        this.rootVertices = new Set(ids.map(node_id_1.normalizeIdToNumberIfPossible));
+        return this;
+    }
+}
+exports.DataflowGraphBuilder = DataflowGraphBuilder;
+//# sourceMappingURL=dataflowgraph-builder.js.map

package/dataflow/graph/diff.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffEdges = exports.diffVertices = exports.diffFunctionArguments = exports.equalFunctionArguments = exports.diffOfDataflowGraphs = exports.DataflowDifferenceReport = void 0;
+exports.DataflowDifferenceReport = void 0;
+exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
+exports.equalFunctionArguments = equalFunctionArguments;
+exports.diffFunctionArguments = diffFunctionArguments;
+exports.diffVertices = diffVertices;
+exports.diffEdges = diffEdges;
 const graph_1 = require("./graph");
 const diff_1 = require("../../util/diff");
 const json_1 = require("../../util/json");
 const arrays_1 = require("../../util/arrays");
+const vertex_1 = require("./vertex");
 const edge_1 = require("./edge");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const diff_2 = require("../environments/diff");
@@ -73,8 +79,8 @@ function diffOutgoingEdges(ctx) {
         if (!ctx.left.hasVertex(id)) {
             if (!ctx.config.leftIsSubgraph) {
                 ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.leftname}. This means that the graph contains an edge but not the corresponding vertex.`);
+                continue;
             }
-            continue;
         }
         diffEdges(ctx, id, edge, rEdges.get(id));
     }
@@ -83,8 +89,8 @@ function diffOutgoingEdges(ctx) {
         if (!ctx.right.hasVertex(id)) {
             if (!ctx.config.rightIsSubgraph) {
                 ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.rightname}. This means that the graph contains an edge but not the corresponding vertex.`);
+                continue;
             }
-            continue;
         }
         if (!ctx.config.leftIsSubgraph && !lEdges.has(id)) {
             diffEdges(ctx, id, undefined, edge);
@@ -104,7 +110,6 @@ function diffOfDataflowGraphs(left, right, config) {
     diff(ctx);
     return ctx.report;
 }
-exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
 function diffFunctionArgumentsReferences(fn, a, b, ctx) {
     if (a === '<value>' || b === '<value>') {
         if (a !== b) {
@@ -125,7 +130,6 @@ function equalFunctionArguments(fn, a, b) {
     diffFunctionArguments(fn, a, b, ctx);
     return ctx.report.isEqual();
 }
-exports.equalFunctionArguments = equalFunctionArguments;
 function diffFunctionArguments(fn, a, b, ctx) {
     if (a === false || b === false) {
         if (a !== b) {
@@ -164,7 +168,6 @@ function diffFunctionArguments(fn, a, b, ctx) {
         }
     }
 }
-exports.diffFunctionArguments = diffFunctionArguments;
 function diffVertices(ctx) {
     // collect vertices from both sides
     const lVert = [...ctx.left.vertices(true)].map(([id, info]) => [id, info]);
@@ -205,8 +208,8 @@ function diffVertices(ctx) {
                 position: `${ctx.position}Vertex ${id} differs in environment. `
             });
         }
-        if (lInfo.tag === "function-call" /* VertexType.FunctionCall */) {
-            if (rInfo.tag !== "function-call" /* VertexType.FunctionCall */) {
+        if (lInfo.tag === vertex_1.VertexType.FunctionCall) {
+            if (rInfo.tag !== vertex_1.VertexType.FunctionCall) {
                 ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
             }
             else {
@@ -245,11 +248,10 @@ function diffVertices(ctx) {
         }
     }
 }
-exports.diffVertices = diffVertices;
 function diffEdge(edge, otherEdge, ctx, id, target) {
     const edgeTypes = (0, edge_1.splitEdgeTypes)(edge.types);
     const otherEdgeTypes = (0, edge_1.splitEdgeTypes)(otherEdge.types);
-    if (edgeTypes.length !== otherEdgeTypes.length) {
+    if ((edgeTypes.length < otherEdgeTypes.length && !ctx.config.leftIsSubgraph) || (edgeTypes.length > otherEdgeTypes.length && !ctx.config.rightIsSubgraph)) {
         ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} differs in number of edge types: ${JSON.stringify([...edgeTypes])} vs ${JSON.stringify([...otherEdgeTypes])}`, { tag: 'edge', from: id, to: target });
     }
     if (edge.types !== otherEdge.types) {
@@ -280,5 +282,4 @@ function diffEdges(ctx, id, lEdges, rEdges) {
         diffEdge(edge, otherEdge, ctx, id, target);
     }
 }
-exports.diffEdges = diffEdges;
 //# sourceMappingURL=diff.js.map

package/dataflow/graph/edge.d.ts

@@ -11,7 +11,7 @@ export interface DataflowGraphEdge {
  * The actual value is represented as a bitmask so use {@link edgeTypesToNames} to get something more human-readable.
  * Similarly, you can access {@link EdgeTypeName} to access the name counterpart.
  */
-export declare const enum EdgeType {
+export declare enum EdgeType {
     /** The edge determines that source reads target */
     Reads = 1,
     /** The edge determines that source is defined by target */
@@ -68,7 +68,7 @@ export declare const enum TraverseEdge {
  * @example
  *
  * ```typescript
- * hasAnyTypeOf(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
+ * edgeIncludesType(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
  *```
  *
  * Counterpart of {@link edgeDoesNotIncludeType}.

package/dataflow/graph/edge.js

@@ -1,16 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldTraverseEdge = exports.edgeDoesNotIncludeType = exports.edgeIncludesType = exports.edgeTypesToNames = exports.splitEdgeTypes = exports.edgeTypeToName = void 0;
+exports.EdgeType = void 0;
+exports.edgeTypeToName = edgeTypeToName;
+exports.splitEdgeTypes = splitEdgeTypes;
+exports.edgeTypesToNames = edgeTypesToNames;
+exports.edgeIncludesType = edgeIncludesType;
+exports.edgeDoesNotIncludeType = edgeDoesNotIncludeType;
+exports.shouldTraverseEdge = shouldTraverseEdge;
+/**
+ * Represents the relationship between the source and the target vertex in the dataflow graph.
+ * The actual value is represented as a bitmask so use {@link edgeTypesToNames} to get something more human-readable.
+ * Similarly, you can access {@link EdgeTypeName} to access the name counterpart.
+ */
+var EdgeType;
+(function (EdgeType) {
+    /** The edge determines that source reads target */
+    EdgeType[EdgeType["Reads"] = 1] = "Reads";
+    /** The edge determines that source is defined by target */
+    EdgeType[EdgeType["DefinedBy"] = 2] = "DefinedBy";
+    /** The edge determines that the source calls the target */
+    EdgeType[EdgeType["Calls"] = 4] = "Calls";
+    /** The source returns target on call */
+    EdgeType[EdgeType["Returns"] = 8] = "Returns";
+    /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
+    EdgeType[EdgeType["DefinesOnCall"] = 16] = "DefinesOnCall";
+    /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
+    EdgeType[EdgeType["DefinedByOnCall"] = 32] = "DefinedByOnCall";
+    /** Formal used as argument to a function call */
+    EdgeType[EdgeType["Argument"] = 64] = "Argument";
+    /** The edge determines that the source is a side effect that happens when the target is called */
+    EdgeType[EdgeType["SideEffectOnCall"] = 128] = "SideEffectOnCall";
+    /** The Edge determines that the reference is affected by a non-standard evaluation (e.g., a for-loop body or a quotation) */
+    EdgeType[EdgeType["NonStandardEvaluation"] = 256] = "NonStandardEvaluation";
+})(EdgeType || (exports.EdgeType = EdgeType = {}));
 const edgeTypeToHumanReadableName = new Map([
-    [1 /* EdgeType.Reads */, "reads" /* EdgeTypeName.Reads */],
-    [2 /* EdgeType.DefinedBy */, "defined-by" /* EdgeTypeName.DefinedBy */],
-    [4 /* EdgeType.Calls */, "calls" /* EdgeTypeName.Calls */],
-    [8 /* EdgeType.Returns */, "returns" /* EdgeTypeName.Returns */],
-    [16 /* EdgeType.DefinesOnCall */, "defines-on-call" /* EdgeTypeName.DefinesOnCall */],
-    [32 /* EdgeType.DefinedByOnCall */, "defined-by-on-call" /* EdgeTypeName.DefinedByOnCall */],
-    [64 /* EdgeType.Argument */, "argument" /* EdgeTypeName.Argument */],
-    [128 /* EdgeType.SideEffectOnCall */, "side-effect-on-call" /* EdgeTypeName.SideEffectOnCall */],
-    [256 /* EdgeType.NonStandardEvaluation */, "non-standard-evaluation" /* EdgeTypeName.NonStandardEvaluation */]
+    [EdgeType.Reads, "reads" /* EdgeTypeName.Reads */],
+    [EdgeType.DefinedBy, "defined-by" /* EdgeTypeName.DefinedBy */],
+    [EdgeType.Calls, "calls" /* EdgeTypeName.Calls */],
+    [EdgeType.Returns, "returns" /* EdgeTypeName.Returns */],
+    [EdgeType.DefinesOnCall, "defines-on-call" /* EdgeTypeName.DefinesOnCall */],
+    [EdgeType.DefinedByOnCall, "defined-by-on-call" /* EdgeTypeName.DefinedByOnCall */],
+    [EdgeType.Argument, "argument" /* EdgeTypeName.Argument */],
+    [EdgeType.SideEffectOnCall, "side-effect-on-call" /* EdgeTypeName.SideEffectOnCall */],
+    [EdgeType.NonStandardEvaluation, "non-standard-evaluation" /* EdgeTypeName.NonStandardEvaluation */]
 ]);
 /**
  * Only use this function to retrieve a human-readable name if you know that it is a single bitmask.
@@ -19,7 +51,6 @@ const edgeTypeToHumanReadableName = new Map([
 function edgeTypeToName(type) {
     return edgeTypeToHumanReadableName.get(type);
 }
-exports.edgeTypeToName = edgeTypeToName;
 function splitEdgeTypes(types) {
     const split = [];
     for (const bit of edgeTypeToHumanReadableName.keys()) {
@@ -29,7 +60,6 @@ function splitEdgeTypes(types) {
     }
     return split;
 }
-exports.splitEdgeTypes = splitEdgeTypes;
 function edgeTypesToNames(bits) {
     const types = new Set();
     for (const [bit, name] of edgeTypeToHumanReadableName.entries()) {
@@ -39,13 +69,12 @@ function edgeTypesToNames(bits) {
     }
     return types;
 }
-exports.edgeTypesToNames = edgeTypesToNames;
 /**
  * Check if the given-edge type has any of the given types.
  * @example
  *
  * ```typescript
- * hasAnyTypeOf(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
+ * edgeIncludesType(EdgeType.Reads, EdgeType.Reads | EdgeType.DefinedBy) // true
  *```
  *
  * Counterpart of {@link edgeDoesNotIncludeType}.
@@ -53,7 +82,6 @@ exports.edgeTypesToNames = edgeTypesToNames;
 function edgeIncludesType(type, types) {
     return (types & type) !== 0;
 }
-exports.edgeIncludesType = edgeIncludesType;
 /**
  * Check if the given-edge type does not include the given type.
  * Counterpart of {@link edgeIncludesType}.
@@ -61,19 +89,17 @@ exports.edgeIncludesType = edgeIncludesType;
 function edgeDoesNotIncludeType(type, types) {
     return (types & type) === 0;
 }
-exports.edgeDoesNotIncludeType = edgeDoesNotIncludeType;
-const alwaysTraverseEdgeTypes = 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 64 /* EdgeType.Argument */ | 4 /* EdgeType.Calls */ | 16 /* EdgeType.DefinesOnCall */;
+const alwaysTraverseEdgeTypes = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.Argument | EdgeType.Calls | EdgeType.DefinesOnCall;
 function shouldTraverseEdge(types) {
     if (edgeIncludesType(types, alwaysTraverseEdgeTypes)) {
         return 3 /* TraverseEdge.Always */;
     }
-    else if (edgeIncludesType(types, 32 /* EdgeType.DefinedByOnCall */)) {
+    else if (edgeIncludesType(types, EdgeType.DefinedByOnCall)) {
         return 2 /* TraverseEdge.DefinedByOnCall */;
     }
-    else if (edgeIncludesType(types, 128 /* EdgeType.SideEffectOnCall */)) {
+    else if (edgeIncludesType(types, EdgeType.SideEffectOnCall)) {
         return 1 /* TraverseEdge.SideEffect */;
     }
     return 0 /* TraverseEdge.Never */;
 }
-exports.shouldTraverseEdge = shouldTraverseEdge;
 //# sourceMappingURL=edge.js.map

package/dataflow/graph/graph.d.ts

@@ -9,12 +9,23 @@ import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/deco
 export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph' | 'exitPoints'> & {
     graph: Set<NodeId>;
 };
+/**
+ * ```r
+ * foo(a = 3, b = 2)
+ * ```
+ */
 export interface NamedFunctionArgument extends IdentifierReference {
     readonly name: string;
 }
+/**
+ * ```r
+ * foo(3, 2)
+ * ```
+ */
 export interface PositionalFunctionArgument extends Omit<IdentifierReference, 'name'> {
     readonly name?: undefined;
 }
+/** Summarizes either named (`foo(a = 3, b = 2)`), unnamed (`foo(3, 2)`), or empty (`foo(,)`) arguments within a function. */
 export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgument | typeof EmptyArgument;
 export declare function isPositionalArgument(arg: FunctionArgument): arg is PositionalFunctionArgument;
 export declare function isNamedArgument(arg: FunctionArgument): arg is NamedFunctionArgument;
@@ -29,9 +40,6 @@ export type OutgoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> =
  * In other words, it maps the source to the edge information.
  */
 export type IngoingEdges<Edge extends DataflowGraphEdge = DataflowGraphEdge> = Map<NodeId, Edge>;
-type EdgeData<Edge extends DataflowGraphEdge> = Omit<Edge, 'from' | 'to' | 'types' | 'attribute'> & {
-    type: EdgeType;
-};
 export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
@@ -126,11 +134,11 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      */
     addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean): this;
     /** {@inheritDoc} */
-    addEdge(from: NodeId, to: NodeId, edgeInfo: EdgeData<Edge>): this;
+    addEdge(from: NodeId, to: NodeId, type: EdgeType): this;
     /** {@inheritDoc} */
-    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, edgeInfo: EdgeData<Edge>): this;
+    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, type: EdgeType): this;
     /** {@inheritDoc} */
-    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, edgeInfo: EdgeData<Edge>): this;
+    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, type: EdgeType): this;
     private installEdge;
     /**
      * Merges the other graph into *this* one (in-place). The return value is only for convenience.