@eagleoutice/flowr 2.2.10 → 2.2.12

package/dataflow/environments/define.js

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDefinitions = mergeDefinitions;
 exports.define = define;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
+const config_1 = require("../../config");
 function defInEnv(newEnvironments, name, definition) {
     const existing = newEnvironments.memory.get(name);
     // When there are defined indices, merge the definitions
     const inGraphDefinition = definition;
-    if (existing !== undefined && inGraphDefinition.indicesCollection !== undefined && inGraphDefinition.controlDependencies === undefined) {
-        newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
-        return;
+    if ((0, config_1.getConfig)().solver.pointerTracking &&
+        existing !== undefined &&
+        inGraphDefinition.controlDependencies === undefined) {
+        if (inGraphDefinition.indicesCollection !== undefined) {
+            newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
+            return;
+        }
+        else if (existing?.flatMap(i => i.indicesCollection ?? []).length > 0) {
+            // When indices couldn't be resolved, but indices where defined before, just add the definition
+            existing.push(definition);
+            return;
+        }
     }
     // check if it is maybe or not
     if (existing === undefined || definition.controlDependencies === undefined) {
@@ -21,28 +32,43 @@ function defInEnv(newEnvironments, name, definition) {
         existing.push(definition);
     }
 }
+/**
+ * assumes: existing is not undefined, the overwrite has indices
+ */
 function mergeDefinitions(existing, definition) {
     // When new definition is not a single index, e.g., a list redefinition, then reset existing definition
     if (definition.indicesCollection?.some(indices => indices.isContainer)) {
         return [definition];
     }
-    const existingDefs = existing.map((def) => def).filter((def) => def !== undefined);
+    const existingDefs = existing.filter(assert_1.isNotUndefined);
     const overwriteIndices = definition.indicesCollection?.flatMap(indices => indices.indices) ?? [];
     // Compare existing and new definitions,
     // add new definitions and remove existing definitions that are overwritten by new definition
     const newExistingDefs = [];
+    const hasCache = new Set();
     for (const overwriteIndex of overwriteIndices) {
         for (const existingDef of existingDefs) {
-            if (existingDef.indicesCollection === undefined) {
+            // empty or missing
+            if (existingDef.indicesCollection === undefined || existingDef.indicesCollection.length === 0) {
+                const existingDefPrint = JSON.stringify(existingDef);
+                if (!hasCache.has(existingDefPrint)) {
+                    newExistingDefs.push(existingDef);
+                    hasCache.add(existingDefPrint);
+                }
                 continue;
             }
             const newIndicesCollection = overwriteContainerIndices(existingDef.indicesCollection, overwriteIndex);
             // if indices are now empty list, don't keep empty definition
             if (newIndicesCollection.length > 0) {
-                newExistingDefs.push({
+                const obj = {
                     ...existingDef,
                     indicesCollection: newIndicesCollection,
-                });
+                };
+                const objHash = JSON.stringify(obj);
+                if (!hasCache.has(objHash)) {
+                    newExistingDefs.push(obj);
+                    hasCache.add(objHash);
+                }
             }
         }
     }
@@ -57,7 +83,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
         if ((0, vertex_1.isParentContainerIndex)(overwriteIndex)) {
             newIndices = [];
             for (const index of indices.indices) {
-                if (index.lexeme === overwriteIndex.lexeme && (0, vertex_1.isParentContainerIndex)(index)) {
+                if ((0, vertex_1.isSameIndex)(index, overwriteIndex) && (0, vertex_1.isParentContainerIndex)(index)) {
                     const overwriteSubIndices = overwriteIndex.subIndices.flatMap(a => a.indices);
                     let newSubIndices = index.subIndices;
                     for (const overwriteSubIndex of overwriteSubIndices) {
@@ -70,7 +96,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
                         });
                     }
                 }
-                if (index.lexeme !== overwriteIndex.lexeme || !(0, vertex_1.isParentContainerIndex)(index)) {
+                if (!(0, vertex_1.isSameIndex)(index, overwriteIndex) || !(0, vertex_1.isParentContainerIndex)(index)) {
                     newIndices.push(index);
                 }
             }
@@ -81,7 +107,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
         }
         else {
             // Filter existing indices with the same name
-            newIndices = indices.indices.filter(def => def.lexeme !== overwriteIndex.lexeme);
+            newIndices = indices.indices.filter(def => !(0, vertex_1.isSameIndex)(def, overwriteIndex));
         }
         if (indices.isContainer || newIndices.length > 0) {
             newIndicesCollection.push({

package/dataflow/environments/environment.js

@@ -81,8 +81,10 @@ exports.EmptyBuiltInEnvironment = {
  * See {@link EmptyBuiltInEnvironment} for the case `fullBuiltIns = false`.
  */
 function initializeCleanEnvironments(fullBuiltIns = true) {
-    exports.BuiltInEnvironment.memory ??= built_in_1.BuiltInMemory;
-    exports.EmptyBuiltInEnvironment.memory ??= built_in_1.EmptyBuiltInMemory;
+    if (exports.BuiltInEnvironment.memory === undefined) {
+        exports.BuiltInEnvironment.memory = built_in_1.BuiltInMemory;
+        exports.EmptyBuiltInEnvironment.memory = built_in_1.EmptyBuiltInMemory;
+    }
     return {
         current: new Environment(fullBuiltIns ? exports.BuiltInEnvironment : exports.EmptyBuiltInEnvironment),
         level: 0

package/dataflow/environments/overwrite.js

@@ -4,6 +4,7 @@ exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
 exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
+const log_1 = require("../../util/log");
 function anyIsMaybeOrEmpty(values) {
     if (values.length === 0) {
         return true;
@@ -19,6 +20,9 @@ function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
     const map = new Map(base.memory);
     for (const [key, values] of next.memory) {
+        if (values.length > 1_000_000) {
+            log_1.log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
+        }
         const hasMaybe = applyCds?.length === 0 || applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);

package/dataflow/environments/remove.d.ts

@@ -0,0 +1,6 @@
+import type { REnvironmentInformation } from './environment';
+import type { Identifier } from './identifier';
+/**
+ * Removes all definitions of a given name from the environment.
+ */
+export declare function remove(name: Identifier, environment: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/remove.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = remove;
+const environment_1 = require("./environment");
+const info_1 = require("../info");
+/**
+ * Removes all definitions of a given name from the environment.
+ */
+function remove(name, environment) {
+    let current = environment.current;
+    do {
+        const definition = current.memory.get(name);
+        if (definition !== undefined) {
+            current.memory.delete(name);
+            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+                break;
+            }
+        }
+        current = current.parent;
+    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    // we never remove built ins
+    return environment;
+}
+//# sourceMappingURL=remove.js.map

package/dataflow/environments/resolve-by-name.js

@@ -58,7 +58,7 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
             }
             else if (filtered.length > 0) {
                 definitions ??= [];
-                definitions.push(...filtered);
+                definitions = definitions.concat(filtered);
             }
         }
         current = current.parent;

package/dataflow/extractor.d.ts

@@ -14,4 +14,4 @@ export declare const processors: DataflowProcessors<ParentInformation>;
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, ast: NormalizedAst<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/extractor.js

@@ -80,9 +80,9 @@ function resolveLinkToSideEffects(ast, graph) {
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-function produceDataFlowGraph(parser, request, ast) {
-    const multifile = Array.isArray(request);
+function produceDataFlowGraph(parser, request, completeAst) {
     let firstRequest;
+    const multifile = Array.isArray(request);
     if (multifile) {
         firstRequest = request[0];
     }
@@ -90,23 +90,25 @@ function produceDataFlowGraph(parser, request, ast) {
         firstRequest = request;
     }
     const dfData = {
-        parser: parser,
-        completeAst: ast,
+        parser,
+        completeAst,
         environment: (0, environment_1.initializeCleanEnvironments)(),
         processors: exports.processors,
         currentRequest: firstRequest,
         controlDependencies: undefined,
         referenceChain: [firstRequest],
     };
-    let df = (0, processor_1.processDataflowFor)(ast.ast, dfData);
+    let df = (0, processor_1.processDataflowFor)(completeAst.ast, dfData);
+    df.graph.sourced.unshift(firstRequest.request === 'file' ? firstRequest.content : '<inline>');
     if (multifile) {
         for (let i = 1; i < request.length; i++) {
+            /* source requests register automatically */
             df = (0, built_in_source_1.standaloneSourceFile)(request[i], dfData, `root-${i}`, df);
         }
     }
     // finally, resolve linkages
     (0, built_in_function_definition_1.updateNestedFunctionCalls)(df.graph, df.environment);
-    resolveLinkToSideEffects(ast, df.graph);
+    resolveLinkToSideEffects(completeAst, df.graph);
     return df;
 }
 //# sourceMappingURL=extractor.js.map

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

@@ -6,6 +6,9 @@ import type { REnvironmentInformation } from '../environments/environment';
 import type { DataflowGraphVertexUse } from './vertex';
 import type { ControlDependency } 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 { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { FlowrSearchInput } from '../../search/flowr-search';
 export declare function emptyGraph(idMap?: AstIdMap): DataflowGraphBuilder;
 export type DataflowGraphEdgeTarget = NodeId | (readonly NodeId[]);
 /**
@@ -82,8 +85,9 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
         controlDependencies?: ControlDependency[];
     }, asRoot?: boolean): this;
     private edgeHelper;
+    private queryHelper;
     /**
-     * Adds a **read edge** (E1).
+     * Adds a **read edge**.
      *
      * @param from - NodeId of the source vertex
      * @param to   - Either a single or multiple target ids.
@@ -91,30 +95,62 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
      */
     reads(from: NodeId, to: DataflowGraphEdgeTarget): this;
     /**
-     * Adds a **defined-by edge** (E2), with from as defined variable, and to
+     * Adds a **read edge** with a query for the from and/or to vertices.
+     *
+     * @param from - Either a node id or a query to find the node id.
+     * @param to - Either a node id or a query to find the node id.
+     * @param data - The data to search in i.e. the dataflow graph.
+     */
+    readsQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
+    /**
+     * Adds a **defined-by edge** with from as defined variable, and to
      * as a variable/function contributing to its definition.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     definedBy(from: NodeId, to: DataflowGraphEdgeTarget): this;
     /**
-     * Adds a **call edge** (E5) with from as caller, and to as callee.
+     * Adds a **defined-by edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definedByQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
+    /**
+     * Adds a **call edge** with from as caller, and to as callee.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     calls(from: NodeId, to: DataflowGraphEdgeTarget): this;
     /**
-     * Adds a **return edge** (E6) with from as function, and to as exit point.
+     * Adds a **call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    callsQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
+    /**
+     * Adds a **return edge** with from as function, and to as exit point.
      *
      * @see {@link DataflowGraphBuilder#reads|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
+     * Adds a **return edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    returnsQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
+    /**
+     * Adds a **defines-on-call edge** with from as variable, and to as its definition
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     definesOnCall(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **defines-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definesOnCallQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
     /**
      * Adds a **defined-by-on-call edge** with from as definition, and to as variable.
      *
@@ -122,23 +158,47 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
      */
     definedByOnCall(from: NodeId, to: DataflowGraphEdgeTarget): this;
     /**
-     * Adds an **argument edge** (E9) with from as function call, and to as argument.
+     * Adds a **defined-by-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definedByOnCallQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
+    /**
+     * Adds an **argument edge** with from as function call, and to as argument.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     argument(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **argument edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    argumentQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
     /**
      * Adds a **non-standard evaluation edge** with from as vertex, and to as vertex.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     nse(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **non-standard evaluation edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    nseQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): this;
     /**
      * Adds a **side-effect-on-call edge** with from as vertex, and to as vertex.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     sideEffectOnCall(from: NodeId, to: DataflowGraphEdgeTarget): this;
+    /**
+     * Adds a **side-effect-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    sideEffectOnCallQuery<P extends Pipeline>(from: FromQueryParam, to: ToQueryParam, data: FlowrSearchInput<P>): 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.
@@ -146,3 +206,13 @@ export declare class DataflowGraphBuilder extends DataflowGraph {
     overwriteRootIds(ids: readonly NodeId[]): this;
 }
 export declare function getBuiltInSideEffect(name: string): LinkTo<RegExp> | undefined;
+interface Query {
+    query: FlowrSearchLike;
+}
+type FromQueryParam = {
+    nodeId: NodeId;
+} | Query;
+type ToQueryParam = {
+    target: DataflowGraphEdgeTarget;
+} | Query;
+export {};

package/dataflow/graph/dataflowgraph-builder.js

@@ -12,6 +12,8 @@ const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-fun
 const built_in_1 = require("../environments/built-in");
 const edge_1 = require("./edge");
 const default_builtin_config_1 = require("../environments/default-builtin-config");
+const flowr_search_executor_1 = require("../../search/flowr-search-executor");
+const assert_1 = require("../../util/assert");
 function emptyGraph(idMap) {
     return new DataflowGraphBuilder(idMap);
 }
@@ -170,8 +172,28 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         }
         return this.addEdge((0, node_id_1.normalizeIdToNumberIfPossible)(from), (0, node_id_1.normalizeIdToNumberIfPossible)(to), type);
     }
+    queryHelper(from, to, data, type) {
+        let fromId;
+        if ('nodeId' in from) {
+            fromId = from.nodeId;
+        }
+        else {
+            const result = (0, flowr_search_executor_1.runSearch)(from.query, data);
+            (0, assert_1.guard)(result.length === 1, `from query result should yield exactly one node, but yielded ${result.length}`);
+            fromId = result[0].node.info.id;
+        }
+        let toIds;
+        if ('target' in to) {
+            toIds = to.target;
+        }
+        else {
+            const result = (0, flowr_search_executor_1.runSearch)(to.query, data);
+            toIds = result.map(r => r.node.info.id);
+        }
+        return this.edgeHelper(fromId, toIds, type);
+    }
     /**
-     * Adds a **read edge** (E1).
+     * Adds a **read edge**.
      *
      * @param from - NodeId of the source vertex
      * @param to   - Either a single or multiple target ids.
@@ -181,7 +203,17 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.edgeHelper(from, to, edge_1.EdgeType.Reads);
     }
     /**
-     * Adds a **defined-by edge** (E2), with from as defined variable, and to
+     * Adds a **read edge** with a query for the from and/or to vertices.
+     *
+     * @param from - Either a node id or a query to find the node id.
+     * @param to - Either a node id or a query to find the node id.
+     * @param data - The data to search in i.e. the dataflow graph.
+     */
+    readsQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.Reads);
+    }
+    /**
+     * Adds a **defined-by edge** with from as defined variable, and to
      * as a variable/function contributing to its definition.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
@@ -190,7 +222,15 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.edgeHelper(from, to, edge_1.EdgeType.DefinedBy);
     }
     /**
-     * Adds a **call edge** (E5) with from as caller, and to as callee.
+     * Adds a **defined-by edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definedByQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.DefinedBy);
+    }
+    /**
+     * Adds a **call edge** with from as caller, and to as callee.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
@@ -198,7 +238,15 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.edgeHelper(from, to, edge_1.EdgeType.Calls);
     }
     /**
-     * Adds a **return edge** (E6) with from as function, and to as exit point.
+     * Adds a **call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    callsQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.Calls);
+    }
+    /**
+     * Adds a **return edge** with from as function, and to as exit point.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
@@ -206,13 +254,29 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         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
+     * Adds a **return edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    returnsQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.Returns);
+    }
+    /**
+     * Adds a **defines-on-call edge** with from as variable, and to as its definition
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     definesOnCall(from, to) {
         return this.edgeHelper(from, to, edge_1.EdgeType.DefinesOnCall);
     }
+    /**
+     * Adds a **defines-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definesOnCallQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.DefinesOnCall);
+    }
     /**
      * Adds a **defined-by-on-call edge** with from as definition, and to as variable.
      *
@@ -222,13 +286,29 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.edgeHelper(from, to, edge_1.EdgeType.DefinedByOnCall);
     }
     /**
-     * Adds an **argument edge** (E9) with from as function call, and to as argument.
+     * Adds a **defined-by-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    definedByOnCallQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.DefinedByOnCall);
+    }
+    /**
+     * Adds an **argument edge** with from as function call, and to as argument.
      *
      * @see {@link DataflowGraphBuilder#reads|reads} for parameters.
      */
     argument(from, to) {
         return this.edgeHelper(from, to, edge_1.EdgeType.Argument);
     }
+    /**
+     * Adds a **argument edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    argumentQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.Argument);
+    }
     /**
      * Adds a **non-standard evaluation edge** with from as vertex, and to as vertex.
      *
@@ -237,6 +317,14 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     nse(from, to) {
         return this.edgeHelper(from, to, edge_1.EdgeType.NonStandardEvaluation);
     }
+    /**
+     * Adds a **non-standard evaluation edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    nseQuery(from, to, data) {
+        return this.queryHelper(from, to, data, edge_1.EdgeType.NonStandardEvaluation);
+    }
     /**
      * Adds a **side-effect-on-call edge** with from as vertex, and to as vertex.
      *
@@ -245,6 +333,14 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
     sideEffectOnCall(from, to) {
         return this.edgeHelper(from, to, edge_1.EdgeType.SideEffectOnCall);
     }
+    /**
+     * Adds a **side-effect-on-call edge** with a query for the from and/or to vertices.
+     *
+     * @see {@link DataflowGraphBuilder#readsQuery|readsQuery} for parameters.
+     */
+    sideEffectOnCallQuery(from, to, data) {
+        return this.queryHelper(from, to, data, 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.

package/dataflow/graph/edge.js

@@ -98,7 +98,10 @@ function edgeDoesNotIncludeType(type, types) {
 const alwaysTraverseEdgeTypes = EdgeType.Reads | EdgeType.DefinedBy | EdgeType.Argument | EdgeType.Calls;
 const definedByOnCallTypes = EdgeType.DefinesOnCall | EdgeType.DefinedByOnCall;
 function shouldTraverseEdge(types) {
-    if (edgeIncludesType(types, alwaysTraverseEdgeTypes)) {
+    if (edgeIncludesType(types, EdgeType.NonStandardEvaluation)) {
+        return 0 /* TraverseEdge.Never */;
+    }
+    else if (edgeIncludesType(types, alwaysTraverseEdgeTypes)) {
         return 3 /* TraverseEdge.Always */;
     }
     else if (edgeIncludesType(types, definedByOnCallTypes)) {

package/dataflow/graph/graph.d.ts

@@ -2,7 +2,7 @@ import type { DataflowGraphEdge, EdgeType } from './edge';
 import type { DataflowInformation } from '../info';
 import type { DataflowGraphVertexArgument, DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from './vertex';
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { IdentifierDefinition, IdentifierReference } from '../environments/identifier';
+import type { Identifier, IdentifierDefinition, IdentifierReference } from '../environments/identifier';
 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 { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
@@ -73,6 +73,7 @@ export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
     readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
+    readonly sourced?: (string | '<inline>')[];
 }
 /**
  * An unknown side effect describes something that we cannot handle correctly (in all cases).
@@ -103,6 +104,8 @@ export type UnknownSidEffect = NodeId | {
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
     private _idMap;
+    /** all file paths included in this dfg */
+    private _sourced;
     private readonly _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
@@ -135,6 +138,9 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     ingoingEdges(id: NodeId): IngoingEdges | undefined;
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap(): AstIdMap | undefined;
+    get sourced(): (string | '<inline>')[];
+    /** Mark this file as being part of the dfg */
+    addFile(source: string | '<inline>'): void;
     /**
      * Retrieves the set of vertices which have side effects that we do not know anything about.
      */
@@ -213,4 +219,9 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      */
     static fromJson(data: DataflowGraphJson): DataflowGraph;
 }
+export interface IEnvironmentJson {
+    readonly id: number;
+    parent: IEnvironmentJson;
+    memory: Record<Identifier, IdentifierDefinition[]>;
+}
 export {};