@eagleoutice/flowr 2.7.6 → 2.8.0

package/dataflow/graph/call-graph.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeCallGraph = computeCallGraph;
+const graph_1 = require("./graph");
+const vertex_1 = require("./vertex");
+const linker_1 = require("../internal/linker");
+const edge_1 = require("./edge");
+const built_in_1 = require("../environments/built-in");
+const defaultmap_1 = require("../../util/collections/defaultmap");
+function reaches(from, to, graph, knownReachability) {
+    const visited = new Set();
+    const toVisit = [from];
+    while (toVisit.length > 0) {
+        const currentId = toVisit.pop();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        if (currentId === to) {
+            knownReachability.get(from).add(to);
+            return true;
+        }
+        else if (knownReachability.get(currentId).has(to)) {
+            knownReachability.get(from).add(to);
+            return true;
+        }
+        visited.add(currentId);
+        for (const [tar] of graph.outgoingEdges(currentId) ?? []) {
+            toVisit.push(tar);
+        }
+    }
+    return false;
+}
+/**
+ * Computes the call graph from the given dataflow graph.
+ */
+function computeCallGraph(graph) {
+    const result = new graph_1.DataflowGraph(graph.idMap);
+    const state = {
+        visited: new Set(),
+        potentials: [],
+        knownReachability: new defaultmap_1.DefaultMap(() => new Set())
+    };
+    for (const [, vert] of graph.vertices(false)) {
+        if (vert?.tag === vertex_1.VertexType.FunctionCall) {
+            processCall(vert, undefined, graph, result, state);
+        }
+        else if (vert?.tag === vertex_1.VertexType.FunctionDefinition) {
+            processFunctionDefinition(vert, undefined, graph, result, state);
+        }
+    }
+    for (const [from, tos] of state.potentials) {
+        for (const to of tos) {
+            if (!result.hasVertex(to)) {
+                const v = graph.getVertex(to, true);
+                if (v) {
+                    processUnknown(v, from, graph, result, state);
+                    if (v.tag === vertex_1.VertexType.FunctionDefinition) {
+                        processFunctionDefinition(v, from, graph, result, state);
+                    }
+                }
+            }
+            else if (!reaches(from, to, result, state.knownReachability)) {
+                result.addEdge(from, to, edge_1.EdgeType.Calls);
+            }
+        }
+    }
+    return result;
+}
+function processCds(vtx, graph, result, state) {
+    for (const tar of vtx.controlDependencies ?? []) {
+        const targetVtx = graph.getVertex(tar.id, true);
+        if (targetVtx) {
+            processUnknown(targetVtx, undefined, graph, result, state);
+        }
+    }
+}
+/**
+ * This tracks the known symbol origins for a function call for which we know that flowr found no targets!
+ */
+function fallbackUntargetedCall(vtx, graph) {
+    // we track all aliases to their roots here, we know there is no known call target
+    const collected = new Set();
+    const visited = new Set();
+    const toVisit = [vtx.id];
+    while (toVisit.length > 0) {
+        const currentId = toVisit.pop();
+        if (visited.has(currentId)) {
+            continue;
+        }
+        visited.add(currentId);
+        const currentVtx = graph.getVertex(currentId, true);
+        if (!currentVtx) {
+            continue;
+        }
+        let addedNew = false;
+        for (const [tar, { types }] of graph.outgoingEdges(currentId) ?? []) {
+            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Returns) && (0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.NonStandardEvaluation | edge_1.EdgeType.Argument)) {
+                addedNew = true;
+                toVisit.push(tar);
+            }
+        }
+        // we have reached our end(s)
+        if (!addedNew && currentId !== vtx.id) {
+            collected.add(currentId);
+        }
+    }
+    return collected;
+}
+function processCall(vtx, from, graph, result, state) {
+    if (from && !reaches(from, vtx.id, result, state.knownReachability)) {
+        result.addEdge(from, vtx.id, edge_1.EdgeType.Calls);
+    }
+    if (state.visited.has(vtx.id)) {
+        return;
+    }
+    result.addVertex(vtx, undefined, true);
+    processCds(vtx, graph, result, state);
+    state.visited.add(vtx.id);
+    // for each call, resolve the targets
+    const tars = (0, linker_1.getAllFunctionCallTargets)(vtx.id, graph, vtx.environment);
+    let addedTarget = false;
+    for (const tar of tars) {
+        if ((0, built_in_1.isBuiltIn)(tar)) {
+            result.addEdge(vtx.id, tar, edge_1.EdgeType.Calls);
+            addedTarget = true;
+            continue;
+        }
+        const targetVtx = graph.getVertex(tar, true);
+        if (targetVtx?.tag !== vertex_1.VertexType.FunctionDefinition) {
+            continue;
+        }
+        addedTarget = true;
+        processFunctionDefinition(targetVtx, vtx.id, graph, result, state);
+    }
+    if (vtx.origin !== 'unnamed') {
+        for (const origs of vtx.origin) {
+            if (origs.startsWith('builtin:')) {
+                addedTarget = true;
+                result.addEdge(vtx.id, (0, built_in_1.builtInId)(origs.substring('builtin:'.length)), edge_1.EdgeType.Calls);
+            }
+        }
+    }
+    if (!addedTarget) {
+        const origs = fallbackUntargetedCall(vtx, graph);
+        for (const ori of origs) {
+            const oriVtx = graph.getVertex(ori, true);
+            if (!oriVtx) {
+                continue;
+            }
+            result.addEdge(vtx.id, ori, edge_1.EdgeType.Calls);
+            const name = graph.idMap?.get(ori);
+            if (name?.lexeme && oriVtx.tag === vertex_1.VertexType.Use) {
+                result.addVertex({
+                    ...oriVtx,
+                    tag: vertex_1.VertexType.FunctionCall,
+                    name: name.lexeme,
+                    onlyBuiltin: false,
+                    origin: ['function'],
+                    args: []
+                }, oriVtx.environment);
+            }
+        }
+    }
+    // handle arguments, traversing the 'reads' and the 'returns' edges
+    for (const [tar, { types }] of graph.outgoingEdges(vtx.id) ?? []) {
+        if ((0, edge_1.edgeDoesNotIncludeType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.Returns | edge_1.EdgeType.Argument)) {
+            continue;
+        }
+        const tVtx = graph.getVertex(tar, true);
+        if (!tVtx) {
+            continue;
+        }
+        processUnknown(tVtx, vtx.id, graph, result, state);
+    }
+}
+function processUnknown(vtx, from, graph, result, state) {
+    switch (vtx.tag) {
+        case vertex_1.VertexType.FunctionCall:
+            processCall(vtx, from, graph, result, state);
+            return;
+        case vertex_1.VertexType.FunctionDefinition:
+            if (from) {
+                result.addEdge(from, (0, built_in_1.builtInId)('function'), edge_1.EdgeType.Calls);
+            }
+            return;
+        default:
+            return;
+    }
+}
+function processFunctionDefinition(vtx, from, graph, result, state) {
+    if (from) {
+        result.addEdge(from, vtx.id, edge_1.EdgeType.Calls);
+    }
+    if (state.visited.has(vtx.id)) {
+        return;
+    }
+    state.visited.add(vtx.id);
+    result.addVertex(vtx, undefined, true);
+    processCds(vtx, graph, result, state);
+    const exits = new Set(vtx.exitPoints);
+    for (const { nodeId } of exits) {
+        const v = graph.getVertex(nodeId, true);
+        if (v) {
+            processUnknown(v, vtx.id, graph, result, state);
+        }
+    }
+    state.potentials.push([vtx.id, vtx.subflow.graph.difference(exits)]);
+}
+//# sourceMappingURL=call-graph.js.map

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

@@ -3,10 +3,11 @@ import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/deco
 import { type DataflowFunctionFlowInformation, DataflowGraph, type FunctionArgument } from './graph';
 import { type IEnvironment, type REnvironmentInformation } from '../environments/environment';
 import { type DataflowGraphVertexArgument, type DataflowGraphVertexAstLink, type DataflowGraphVertexInfo, type DataflowGraphVertexUse, type FunctionOriginInformation } from './vertex';
-import type { ControlDependency } from '../info';
+import type { ControlDependency, ExitPoint } from '../info';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 import type { FlowrSearchLike } from '../../search/flowr-search-builder';
 import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import type { HookInformation } from '../hooks';
 /**
  * Creates an empty dataflow graph.
  * Should only be used in tests and documentation.
@@ -31,10 +32,13 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
      * @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?: {
+    defineFunction(id: NodeId, exitPoints: readonly ExitPoint[] | readonly NodeId[], subflow: Omit<DataflowFunctionFlowInformation, 'hooks'> & {
+        hooks?: HookInformation[];
+    }, info?: {
         environment?: REnvironmentInformation;
         builtInEnvironment?: IEnvironment;
         controlDependencies?: ControlDependency[];
+        readParams?: [NodeId, boolean][];
     }, asRoot?: boolean): this;
     /**
      * Adds a **vertex** for a **function call** (V2).
@@ -54,6 +58,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
         controlDependencies?: ControlDependency[];
         origin?: FunctionOriginInformation[];
         link?: DataflowGraphVertexAstLink;
+        omitArgs?: boolean;
     }, asRoot?: boolean): this;
     /** automatically adds argument links if they do not already exist */
     private addArgumentLinks;

package/dataflow/graph/dataflowgraph-builder.js

@@ -49,16 +49,19 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.FunctionDefinition,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
+            params: Object.fromEntries(info?.readParams ?? []),
             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) })) }))
+                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) })) })),
+                hooks: subflow.hooks ?? []
             },
-            exitPoints: exitPoints.map(node_id_1.normalizeIdToNumberIfPossible),
-            cds: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e.nodeId), controlDependencies: e.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }) :
+                ({ nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e), type: 0 /* ExitPointType.Default */, controlDependencies: undefined })),
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
             environment: info?.environment,
         }, asRoot);
     }
@@ -79,12 +82,14 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             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 ?? this.defaultEnvironment,
-            cds: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
             onlyBuiltin: info?.onlyBuiltIn ?? onlyBuiltInAuto ?? false,
             origin: info?.origin ?? [(0, default_builtin_config_1.getDefaultProcessor)(name) ?? 'function'],
             link: info?.link
         }, asRoot);
-        this.addArgumentLinks(id, args);
+        if (!info?.omitArgs) {
+            this.addArgumentLinks(id, args);
+        }
         if (info?.returns) {
             for (const ret of info.returns) {
                 this.returns(id, ret);
@@ -129,7 +134,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             tag: vertex_1.VertexType.VariableDefinition,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
-            cds: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
         }, asRoot);
         if (info?.definedBy) {
             for (const def of info.definedBy) {
@@ -151,11 +156,11 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             tag: vertex_1.VertexType.Use,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
-            cds: undefined,
+            controlDependencies: undefined,
             environment: undefined
         }, {
             ...info,
-            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
+            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
         }), asRoot);
     }
     /**
@@ -169,7 +174,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.Value,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
-            cds: options?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            controlDependencies: options?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
             environment: undefined
         }, asRoot);
     }

package/dataflow/graph/diff-dataflow-graph.js

@@ -168,7 +168,7 @@ function diffVertices(ctx) {
                 });
             }
         }
-        (0, info_1.diffControlDependencies)(lInfo.cds, rInfo.cds, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
+        (0, info_1.diffControlDependencies)(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
         if (lInfo.origin !== undefined || rInfo.origin !== undefined) {
             // compare arrays
             const equalArrays = lInfo.origin && rInfo.origin && (0, arrays_1.arrayEqual)(lInfo.origin, rInfo.origin);
@@ -212,7 +212,13 @@ function diffVertices(ctx) {
                 ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`, { tag: 'vertex', id });
             }
             else {
-                if (!(0, arrays_1.arrayEqual)(lInfo.exitPoints, rInfo.exitPoints)) {
+                if (!(0, arrays_1.arrayEqual)(lInfo.exitPoints, rInfo.exitPoints, (a, b) => {
+                    if (a.type !== b.type || a.nodeId !== b.nodeId) {
+                        return false;
+                    }
+                    (0, info_1.diffControlDependencies)(a.controlDependencies, b.controlDependencies, { ...ctx, position: '' });
+                    return true;
+                })) {
                     ctx.report.addComment(`Vertex ${id} differs in exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`, { tag: 'vertex', id });
                 }
                 if ((lInfo.subflow.environment === undefined && rInfo.subflow.environment !== undefined && !ctx.config.leftIsSubgraph)
@@ -222,14 +228,102 @@ function diffVertices(ctx) {
                         position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. `
                     });
                 }
+                diffInReadParameters(lInfo.params, rInfo.params, {
+                    ...ctx,
+                    position: `${ctx.position}Vertex ${id} differs in subflow in-read-parameters. `
+                });
                 (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, {
                     ...ctx,
                     position: `${ctx.position}Vertex ${id} differs in subflow graph. `
                 });
+                diffReferenceLists(id, lInfo.subflow.in, rInfo.subflow.in, {
+                    ...ctx,
+                    position: `${ctx.position}Vertex ${id} differs in subflow *in* refs. `
+                });
+                diffReferenceLists(id, lInfo.subflow.out, rInfo.subflow.out, {
+                    ...ctx,
+                    position: `${ctx.position}Vertex ${id} differs in subflow *out* refs. `
+                });
+                diffReferenceLists(id, lInfo.subflow.unknownReferences, rInfo.subflow.unknownReferences, {
+                    ...ctx,
+                    position: `${ctx.position}Vertex ${id} differs in subflow *unknown* refs. `
+                });
+                diffHooks(lInfo.subflow.hooks, rInfo.subflow.hooks, ctx, id);
+            }
+        }
+    }
+}
+function diffInReadParameters(l, r, ctx) {
+    const lKeys = new Set(Object.keys(l));
+    const rKeys = new Set(Object.keys(r));
+    (0, diff_1.setDifference)(lKeys, rKeys, { ...ctx, position: `${ctx.position}In-read-parameters differ in graphs. ` });
+    for (const k of lKeys) {
+        const lVal = l[k];
+        const rVal = r[k];
+        if (rVal === undefined) {
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`In-read-parameter ${k} is not present in ${ctx.rightname}`, { tag: 'vertex', id: k });
+            }
+            continue;
+        }
+        if (lVal !== rVal) {
+            ctx.report.addComment(`In-read-parameter ${k} differs. ${ctx.leftname}: ${lVal} vs ${ctx.rightname}: ${rVal}`, { tag: 'vertex', id: k });
+        }
+    }
+    for (const k of rKeys) {
+        if (!lKeys.has(k)) {
+            if (!ctx.config.leftIsSubgraph) {
+                ctx.report.addComment(`In-read-parameter ${k} is not present in ${ctx.leftname}`, { tag: 'vertex', id: k });
             }
         }
     }
 }
+function diffReferenceLists(fn, a, b, ctx) {
+    // sort by id
+    if (a === undefined || b === undefined) {
+        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)}`, { tag: 'vertex', id: fn });
+        }
+        return;
+    }
+    if (a.length !== b.length) {
+        ctx.report.addComment(`${ctx.position}Differs in number of references.\n   - ${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs\n   - ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`, { tag: 'vertex', id: fn });
+        return;
+    }
+    const aSorted = [...a].sort((x, y) => x.nodeId.toString().localeCompare(y.nodeId.toString()));
+    const bSorted = [...b].sort((x, y) => x.nodeId.toString().localeCompare(y.nodeId.toString()));
+    for (let i = 0; i < aSorted.length; ++i) {
+        (0, diff_2.diffIdentifierReferences)(aSorted[i], bSorted[i], {
+            ...ctx,
+            position: `${ctx.position}In reference #${i} ("${aSorted[i].name ?? '?'}", id: ${aSorted[i].nodeId ?? '?'}) `,
+        });
+    }
+}
+function diffHooks(left, right, ctx, id) {
+    // compare length
+    if (left.length !== right.length) {
+        ctx.report.addComment(`Differs in number of hooks. ${ctx.leftname}: ${JSON.stringify(left, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(right, json_1.jsonReplacer)}`, { tag: 'vertex', id });
+        return;
+    }
+    // compare each hook
+    for (let i = 0; i < left.length; ++i) {
+        const lHook = left[i];
+        const rHook = right[i];
+        if (lHook.type !== rHook.type) {
+            ctx.report.addComment(`Hook #${i} differs in type. ${ctx.leftname}: ${JSON.stringify(lHook.type)} vs ${ctx.rightname}: ${JSON.stringify(rHook.type)}`, { tag: 'vertex', id });
+        }
+        if (lHook.id !== rHook.id) {
+            ctx.report.addComment(`Hook #${i} differs in id. ${ctx.leftname}: ${lHook.id} vs ${ctx.rightname}: ${rHook.id}`, { tag: 'vertex', id });
+        }
+        if (lHook.add !== rHook.add) {
+            ctx.report.addComment(`Hook #${i} differs in add. ${ctx.leftname}: ${lHook.add} vs ${ctx.rightname}: ${rHook.add}`, { tag: 'vertex', id });
+        }
+        if (lHook.after !== rHook.after) {
+            ctx.report.addComment(`Hook #${i} differs in after. ${ctx.leftname}: ${lHook.after} vs ${ctx.rightname}: ${rHook.after}`, { tag: 'vertex', id });
+        }
+        (0, info_1.diffControlDependencies)(lHook.cds, rHook.cds, { ...ctx, position: `Hook #${i} differs in control dependencies. ` });
+    }
+}
 function diffEdge(edge, otherEdge, ctx, id, target) {
     const edgeTypes = (0, edge_1.splitEdgeTypes)(edge.types);
     const otherEdgeTypes = (0, edge_1.splitEdgeTypes)(otherEdge.types);

package/dataflow/graph/graph.d.ts

@@ -52,10 +52,6 @@ export declare function isNamedArgument(arg: FunctionArgument): arg is NamedFunc
  * Returns the reference of a non-empty argument.
  */
 export declare function getReferenceOfArgument(arg: FunctionArgument): NodeId | undefined;
-/**
- * A reference that is enough to indicate start and end points of an edge within the dataflow graph.
- */
-type ReferenceForEdge = Pick<IdentifierReference, 'nodeId' | 'controlDependencies'> | IdentifierDefinition;
 /**
  * Maps the edges target to the edge information
  */
@@ -184,9 +180,17 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /** {@inheritDoc} */
     addEdge(from: NodeId, to: NodeId, type: EdgeType | number): this;
     /** {@inheritDoc} */
-    addEdge(from: ReferenceForEdge, to: ReferenceForEdge, type: EdgeType | number): this;
+    addEdge(from: {
+        nodeId: NodeId;
+    }, to: {
+        nodeId: NodeId;
+    }, type: EdgeType | number): this;
     /** {@inheritDoc} */
-    addEdge(from: NodeId | ReferenceForEdge, to: NodeId | ReferenceForEdge, type: EdgeType | number): this;
+    addEdge(from: NodeId | {
+        nodeId: NodeId;
+    }, to: NodeId | {
+        nodeId: NodeId;
+    }, type: EdgeType | number): 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
@@ -222,4 +226,3 @@ export interface IEnvironmentJson {
     memory: Record<Identifier, IdentifierDefinition[]>;
     builtInEnv: true | undefined;
 }
-export {};

package/dataflow/graph/graph.js

@@ -206,11 +206,10 @@ class DataflowGraph {
             return this;
         }
         const fallback = vertex.tag === vertex_1.VertexType.FunctionDefinition || (vertex.tag === vertex_1.VertexType.FunctionCall && !vertex.onlyBuiltin) ? fallbackEnv : undefined;
-        // keep a clone of the original environment
-        const environment = vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : fallback;
         this.vertexInformation.set(vertex.id, {
             ...vertex,
-            environment
+            // keep a clone of the original environment
+            environment: vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : fallback
         });
         const has = this.types.get(vertex.tag);
         if (has) {
@@ -304,7 +303,7 @@ class DataflowGraph {
         const vertex = this.getVertex(reference.nodeId, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set reference`);
         if (vertex.tag === vertex_1.VertexType.FunctionDefinition || vertex.tag === vertex_1.VertexType.VariableDefinition) {
-            vertex.cds = reference.controlDependencies;
+            vertex.controlDependencies = reference.controlDependencies;
         }
         else {
             this.vertexInformation.set(reference.nodeId, { ...vertex, tag: vertex_1.VertexType.VariableDefinition });
@@ -329,17 +328,17 @@ class DataflowGraph {
         to = to ? (0, node_id_1.normalizeIdToNumberIfPossible)(to) : undefined;
         const vertex = this.getVertex(from, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
-        vertex.cds ??= [];
+        vertex.controlDependencies ??= [];
         if (to) {
             let hasControlDependency = false;
-            for (const { id, when: cond } of vertex.cds) {
+            for (const { id, when: cond } of vertex.controlDependencies) {
                 if (id === to && when !== cond) {
                     hasControlDependency = true;
                     break;
                 }
             }
             if (!hasControlDependency) {
-                vertex.cds.push({ id: to, when });
+                vertex.controlDependencies.push({ id: to, when });
             }
         }
         return this;
@@ -396,7 +395,7 @@ function mergeNodeInfos(current, next) {
     return current;
 }
 /**
- * Returns the ids of the dataflow vertices referenced by a {@link ReferenceForEdge}.
+ * Returns the ids of the dataflow vertices referenced.
  */
 function extractEdgeIds(from, to) {
     const fromId = typeof from === 'object' ? from.nodeId : from;

package/dataflow/graph/vertex.d.ts

@@ -2,7 +2,7 @@ import type { MergeableRecord } from '../../util/objects';
 import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../environments/environment';
-import type { ControlDependency } from '../info';
+import type { ControlDependency, ExitPoint } from '../info';
 import type { BuiltInMappingName } from '../environments/built-in';
 export declare enum VertexType {
     Value = "value",
@@ -137,7 +137,7 @@ interface DataflowGraphVertexBase extends MergeableRecord {
     /**
      * @see {@link ControlDependency} - the collection of control dependencies which have an influence on whether the vertex is executed.
      */
-    cds: ControlDependency[] | undefined;
+    controlDependencies: ControlDependency[] | undefined;
     /**
      * this attribute links a vertex to indices (pointer links) it may be affected by or related to
      */
@@ -235,7 +235,10 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
      * All exit points of the function definitions.
      * In other words: last expressions/return calls
      */
-    exitPoints: readonly NodeId[];
+    exitPoints: readonly ExitPoint[];
+    /** Maps each param to whether it is read, this is an estimate! */
+    params: Record<NodeId, boolean>;
+    /** The environment in which the function is defined (this is only attached if the DFG deems it necessary). */
     environment?: REnvironmentInformation;
 }
 /**

package/dataflow/hooks.d.ts

@@ -0,0 +1,30 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ControlDependency } from './info';
+export declare enum KnownHooks {
+    /** Triggers on the exit of a function, no matter how this exit is enforced. */
+    OnFnExit = "fn-exit"
+}
+/**
+ * Information about a registered hook within the dataflow information.
+ */
+export interface HookInformation {
+    /** The type of the hook */
+    type: KnownHooks;
+    /** The id of the function definition which is added by the hook */
+    id: NodeId;
+    /** Control dependencies under which the hook was registered */
+    cds?: ControlDependency[];
+    /** Whether the hook is added on top of existing ones (true) or replaces them (false) */
+    add?: boolean;
+    /** Whether the hook is executed after existing ones (true) or before (false) */
+    after?: boolean;
+}
+/**
+ * Compacts a list of hook registrations by removing redundant and dominated ones.
+ */
+export declare function compactHookStates(hooks: HookInformation[]): HookInformation[];
+/**
+ * Extracts all hooks of the given type from the list of hooks.
+ * Please consider {@link compactHookStates} to remove redundant or dominated hooks first.
+ */
+export declare function getHookInformation(hooks: HookInformation[], type: KnownHooks): HookInformation[];

package/dataflow/hooks.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownHooks = void 0;
+exports.compactHookStates = compactHookStates;
+exports.getHookInformation = getHookInformation;
+const info_1 = require("./info");
+const defaultmap_1 = require("../util/collections/defaultmap");
+var KnownHooks;
+(function (KnownHooks) {
+    /** Triggers on the exit of a function, no matter how this exit is enforced. */
+    KnownHooks["OnFnExit"] = "fn-exit";
+})(KnownHooks || (exports.KnownHooks = KnownHooks = {}));
+/**
+ * Compacts a list of hook registrations by removing redundant and dominated ones.
+ */
+function compactHookStates(hooks) {
+    const hooksByType = new defaultmap_1.DefaultMap(() => []);
+    for (const hook of hooks) {
+        if (!hook.add && (0, info_1.happensInEveryBranch)(hook.cds)) {
+            hooksByType.set(hook.type, [hook]);
+        }
+        else if (hook.after) {
+            hooksByType.get(hook.type).push(hook);
+        }
+        else {
+            hooksByType.get(hook.type).unshift(hook);
+        }
+    }
+    return hooksByType.values().flatMap(f => f).toArray();
+}
+/**
+ * Extracts all hooks of the given type from the list of hooks.
+ * Please consider {@link compactHookStates} to remove redundant or dominated hooks first.
+ */
+function getHookInformation(hooks, type) {
+    return hooks.filter(h => h.type === type);
+}
+//# sourceMappingURL=hooks.js.map