@eagleoutice/flowr 2.6.2 → 2.7.0

package/dataflow/eval/values/string/string-constants.js

@@ -7,7 +7,8 @@ exports.collectStrings = collectStrings;
 const general_1 = require("../general");
 const r_value_1 = require("../r-value");
 /**
- *
+ * Lift a raw string or R string value into a ValueString.
+ * @see {@link liftString} - for lifting a Lift<RStringValue>
  */
 function stringFrom(str) {
     return {
@@ -19,7 +20,8 @@ function stringFrom(str) {
     };
 }
 /**
- *
+ * Lift a Lift<RStringValue> into a ValueString.
+ * @see {@link stringFrom} - for lifting a raw string or R string value.
  */
 function liftString(str) {
     return {
@@ -28,7 +30,11 @@ function liftString(str) {
     };
 }
 /**
- *
+ * Collect strings from an array of ValueString.
+ * If any value is not a string, or is Bottom/Top, undefined is returned.
+ * @param a           - The array of Value to collect strings from.
+ * @param withQuotes  - Whether to include the quotes in the returned strings.
+ * @returns           - An array of strings, or undefined if any value is not a string.
  */
 function collectStrings(a, withQuotes = false) {
     if ((0, general_1.bottomTopGuard)(a)) {

package/dataflow/extractor.d.ts

@@ -1,10 +1,9 @@
 import type { DataflowInformation } from './info';
 import { type DataflowProcessors } from './processor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RParseRequests } from '../r-bridge/retriever';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
-import type { FlowrConfigOptions } from '../config';
+import type { FlowrAnalyzerContext } from '../project/context/flowr-analyzer-context';
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -16,6 +15,6 @@ 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, completeAst: NormalizedAst<OtherInfo & ParentInformation>, config: FlowrConfigOptions): DataflowInformation & {
+export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, completeAst: NormalizedAst<OtherInfo & ParentInformation>, ctx: FlowrAnalyzerContext): DataflowInformation & {
     cfgQuick: ControlFlowInformation | undefined;
 };

package/dataflow/extractor.js

@@ -14,13 +14,12 @@ const named_call_handling_1 = require("./internal/process/functions/call/named-c
 const make_argument_1 = require("./internal/process/functions/call/argument/make-argument");
 const range_1 = require("../util/range");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
-const environment_1 = require("./environments/environment");
 const built_in_source_1 = require("./internal/process/functions/call/built-in/built-in-source");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
-const built_in_config_1 = require("./environments/built-in-config");
+const flowr_file_1 = require("../project/context/flowr-file");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -60,13 +59,24 @@ exports.processors = {
 };
 function resolveLinkToSideEffects(ast, graph) {
     let cf = undefined;
+    let knownCalls;
+    const handled = new Set();
     for (const s of graph.unknownSideEffects) {
         if (typeof s !== 'object') {
             continue;
         }
-        cf ??= (0, extract_cfg_1.extractCfgQuick)(ast);
+        if (cf === undefined) {
+            cf = (0, extract_cfg_1.extractCfgQuick)(ast);
+            if (graph.unknownSideEffects.size > 20) {
+                knownCalls = (0, extract_cfg_1.getCallsInCfg)(cf, graph);
+            }
+        }
+        else if (handled.has(s.id)) {
+            continue;
+        }
+        handled.add(s.id);
         /* this has to change whenever we add a new link to relations because we currently offer no abstraction for the type */
-        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cf?.graph, graph, s.linkTo);
+        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cf.graph, graph, s.linkTo, knownCalls);
         for (const pot of potentials) {
             graph.addEdge(s.id, pot, edge_1.EdgeType.Reads);
         }
@@ -82,36 +92,23 @@ 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, completeAst, config) {
-    let firstRequest;
-    const multifile = Array.isArray(request);
-    if (multifile) {
-        firstRequest = request[0];
-    }
-    else {
-        firstRequest = request;
-    }
-    const builtInsConfig = config.semantics.environment.overwriteBuiltIns;
-    const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
-    const env = (0, environment_1.initializeCleanEnvironments)(builtIns.builtInMemory);
+function produceDataFlowGraph(parser, completeAst, ctx) {
+    // we freeze the files here to avoid endless modifications during processing
+    const files = completeAst.ast.files.slice();
+    ctx.files.addConsideredFile(files[0].filePath ? files[0].filePath : flowr_file_1.FlowrFile.INLINE_PATH);
     const dfData = {
         parser,
         completeAst,
-        environment: env,
-        builtInEnvironment: env.current.parent,
+        environment: ctx.env.makeCleanEnv(),
         processors: exports.processors,
-        currentRequest: firstRequest,
         controlDependencies: undefined,
-        referenceChain: [firstRequest],
-        flowrConfig: config
+        referenceChain: [files[0].filePath],
+        ctx
     };
-    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);
-        }
+    let df = (0, processor_1.processDataflowFor)(files[0].root, dfData);
+    for (let i = 1; i < files.length; i++) {
+        /* source requests register automatically */
+        df = (0, built_in_source_1.standaloneSourceFile)(i, files[i], dfData, df);
     }
     // finally, resolve linkages
     (0, built_in_function_definition_1.updateNestedFunctionCalls)(df.graph, df.environment);

package/dataflow/fn/higher-order-function.d.ts

@@ -1,9 +1,10 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowGraph } from '../graph/graph';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Determines whether the function with the given id is a higher-order function, i.e.,
  * either takes a function as an argument or (may) returns a function.
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
  */
-export declare function isHigherOrder(id: NodeId, graph: DataflowGraph): boolean;
+export declare function isHigherOrder(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): boolean;

package/dataflow/fn/higher-order-function.js

@@ -32,7 +32,7 @@ function isAnyReturnAFunction(def, graph) {
     }
     return false;
 }
-function inspectCallSitesArgumentsFns(def, graph) {
+function inspectCallSitesArgumentsFns(def, graph, ctx) {
     const callSites = graph.ingoingEdges(def.id);
     for (const [callerId, { types }] of callSites ?? []) {
         if (!(0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls)) {
@@ -46,7 +46,7 @@ function inspectCallSitesArgumentsFns(def, graph) {
             if (arg === r_function_call_1.EmptyArgument) {
                 continue;
             }
-            const value = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.nodeId, { graph, idMap: graph.idMap, resolve: config_1.VariableResolve.Alias, full: true }));
+            const value = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.nodeId, { graph, idMap: graph.idMap, resolve: config_1.VariableResolve.Alias, full: true, ctx }));
             if (value?.elements.some(e => e.type === 'function-definition')) {
                 return true;
             }
@@ -60,7 +60,7 @@ function inspectCallSitesArgumentsFns(def, graph) {
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
  */
-function isHigherOrder(id, graph) {
+function isHigherOrder(id, graph, ctx) {
     const vert = graph.getVertex(id);
     if (!vert || !(0, vertex_1.isFunctionDefinitionVertex)(vert)) {
         return false;
@@ -70,6 +70,6 @@ function isHigherOrder(id, graph) {
         return true;
     }
     // 2. check whether any of the callsites passes a function
-    return inspectCallSitesArgumentsFns(vert, graph);
+    return inspectCallSitesArgumentsFns(vert, graph, ctx);
 }
 //# sourceMappingURL=higher-order-function.js.map

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

@@ -1,23 +1,27 @@
 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, type FunctionArgument, DataflowGraph } from './graph';
+import { type DataflowFunctionFlowInformation, DataflowGraph, type FunctionArgument } from './graph';
 import { type IEnvironment, type REnvironmentInformation } from '../environments/environment';
-import { type DataflowGraphVertexAstLink, type DataflowGraphVertexUse, type FunctionOriginInformation } from './vertex';
+import { type DataflowGraphVertexArgument, type DataflowGraphVertexAstLink, type DataflowGraphVertexInfo, type DataflowGraphVertexUse, type FunctionOriginInformation } 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 { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 /**
- *
+ * Creates an empty dataflow graph.
+ * Should only be used in tests and documentation.
  */
-export declare function emptyGraph(idMap?: AstIdMap): DataflowGraphBuilder;
+export declare function emptyGraph(cleanEnv?: REnvironmentInformation, idMap?: AstIdMap): DataflowGraphBuilder<DataflowGraphVertexInfo>;
 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 {
+export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo> extends DataflowGraph {
+    private readonly defaultEnvironment;
+    constructor(cleanEnv?: REnvironmentInformation, idMap?: AstIdMap);
+    addVertexWithDefaultEnv(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean, overwrite?: boolean): this;
     /**
      * Adds a **vertex** for a **function definition** (V1).
      * @param id - AST node ID

package/dataflow/graph/dataflowgraph-builder.js

@@ -6,7 +6,6 @@ exports.getBuiltInSideEffect = getBuiltInSideEffect;
 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");
@@ -14,11 +13,13 @@ 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");
+const flowr_analyzer_context_1 = require("../../project/context/flowr-analyzer-context");
 /**
- *
+ * Creates an empty dataflow graph.
+ * Should only be used in tests and documentation.
  */
-function emptyGraph(idMap) {
-    return new DataflowGraphBuilder(idMap);
+function emptyGraph(cleanEnv, idMap) {
+    return new DataflowGraphBuilder(cleanEnv, idMap);
 }
 /**
  * This DataflowGraphBuilder extends {@link DataflowGraph} with builder methods to
@@ -26,6 +27,15 @@ function emptyGraph(idMap) {
  * simplifies writing tests for dataflow graphs.
  */
 class DataflowGraphBuilder extends graph_1.DataflowGraph {
+    defaultEnvironment;
+    constructor(cleanEnv, idMap) {
+        super(idMap);
+        this.defaultEnvironment = cleanEnv ?? (0, flowr_analyzer_context_1.contextFromInput)('').env.makeCleanEnv();
+    }
+    addVertexWithDefaultEnv(vertex, asRoot = true, overwrite = false) {
+        super.addVertex(vertex, this.defaultEnvironment, asRoot, overwrite);
+        return this;
+    }
     /**
      * Adds a **vertex** for a **function definition** (V1).
      * @param id - AST node ID
@@ -36,7 +46,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (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({
+        return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.FunctionDefinition,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             subflow: {
@@ -49,7 +59,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             },
             exitPoints: exitPoints.map(node_id_1.normalizeIdToNumberIfPossible),
             cds: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
-            environment: info?.environment
+            environment: info?.environment,
         }, asRoot);
     }
     /**
@@ -63,12 +73,12 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      */
     call(id, name, args, info, asRoot = true) {
         const onlyBuiltInAuto = info?.reads?.length === 1 && (0, built_in_1.isBuiltIn)(info?.reads[0]);
-        this.addVertex({
+        this.addVertexWithDefaultEnv({
             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)(),
+            environment: (info?.onlyBuiltIn || onlyBuiltInAuto) ? undefined : info?.environment ?? this.defaultEnvironment,
             cds: 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'],
@@ -115,7 +125,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (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({
+        this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.VariableDefinition,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
@@ -137,7 +147,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (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)({
+        return this.addVertexWithDefaultEnv((0, objects_1.deepMergeObject)({
             tag: vertex_1.VertexType.Use,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
@@ -156,7 +166,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
      * (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({
+        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) })),

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

@@ -207,8 +207,8 @@ function diffVertices(ctx) {
                 }
             }
         }
-        if (lInfo.tag === 'function-definition') {
-            if (rInfo.tag !== 'function-definition') {
+        if (lInfo.tag === vertex_1.VertexType.FunctionDefinition) {
+            if (rInfo.tag !== vertex_1.VertexType.FunctionDefinition) {
                 ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`, { tag: 'vertex', id });
             }
             else {

package/dataflow/graph/graph.d.ts

@@ -4,6 +4,7 @@ import { type DataflowGraphVertexArgument, type DataflowGraphVertexFunctionCall,
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { Identifier, IdentifierDefinition, IdentifierReference } from '../environments/identifier';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type REnvironmentInformation } from '../environments/environment';
 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';
 /**
@@ -71,15 +72,15 @@ export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
     readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
-    readonly sourced?: (string | '<inline>')[];
+    readonly _unknownSideEffects: UnknownSideEffect[];
 }
 /**
  * An unknown side effect describes something that we cannot handle correctly (in all cases).
- * For example, `eval` will be marked as an unknown side effect as we have no idea of how it will affect the program.
+ * For example, `load` will be marked as an unknown side effect as we have no idea of how it will affect the program.
  * Linked side effects are used whenever we know that a call may be affected by another one in a way that we cannot
  * grasp from the dataflow perspective (e.g., an indirect dependency based on the currently active graphic device).
  */
-export type UnknownSidEffect = NodeId | {
+export type UnknownSideEffect = NodeId | {
     id: NodeId;
     linkTo: LinkTo<RegExp>;
 };
@@ -99,10 +100,7 @@ export type UnknownSidEffect = NodeId | {
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 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) */
@@ -111,6 +109,8 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     private vertexInformation;
     /** All edges in the complete graph (including those nested in function definition) */
     private edgeInformation;
+    private types;
+    toJSON(): DataflowGraphJson;
     /**
      * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
      * @param id                      - The id of the node to get
@@ -138,13 +138,10 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     getLinked(nodeId: NodeId): NodeId[] | 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.
      */
-    get unknownSideEffects(): Set<UnknownSidEffect>;
+    get unknownSideEffects(): Set<UnknownSideEffect>;
     /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
     setIdMap(idMap: AstIdMap): void;
     /**
@@ -153,6 +150,10 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      * @see #edges
      */
     vertices(includeDefinedFunctions: boolean): MapIterator<[NodeId, Vertex]>;
+    verticesOfType<T extends Vertex['tag']>(type: T): MapIterator<[NodeId, Vertex & {
+        tag: T;
+    }]>;
+    vertexIdsOfType<T extends Vertex['tag']>(type: T): NodeId[];
     /**
      * @returns the ids of all edges in the graph together with their edge information
      * @see #vertices
@@ -172,13 +173,14 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /**
      * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
      * @param vertex - The vertex to add
+     * @param fallbackEnv - A clean environment to use if no environment is given in the vertex
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean, overwrite?: boolean): this;
+    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, fallbackEnv: REnvironmentInformation, asRoot?: boolean, overwrite?: boolean): this;
     /** {@inheritDoc} */
     addEdge(from: NodeId, to: NodeId, type: EdgeType | number): this;
     /** {@inheritDoc} */

package/dataflow/graph/graph.js

@@ -51,10 +51,7 @@ function getReferenceOfArgument(arg) {
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 class DataflowGraph {
-    static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
-    /** all file paths included in this dfg */
-    _sourced = [];
     /*
      * Set of vertices which have sideEffects that we do not know anything about.
      * As a (temporary) solution until we have FD edges, a side effect may also store known target links
@@ -62,7 +59,6 @@ class DataflowGraph {
      */
     _unknownSideEffects = new Set();
     constructor(idMap) {
-        DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
         this._idMap = idMap;
     }
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
@@ -71,6 +67,15 @@ class DataflowGraph {
     vertexInformation = new Map();
     /** All edges in the complete graph (including those nested in function definition) */
     edgeInformation = new Map();
+    types = new Map();
+    toJSON() {
+        return {
+            rootVertices: Array.from(this.rootVertices),
+            vertexInformation: Array.from(this.vertexInformation.entries()),
+            edgeInformation: Array.from(this.edgeInformation.entries()).map(([id, edges]) => [id, Array.from(edges.entries())]),
+            _unknownSideEffects: Array.from(this._unknownSideEffects)
+        };
+    }
     /**
      * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
      * @param id                      - The id of the node to get
@@ -127,13 +132,6 @@ class DataflowGraph {
     get idMap() {
         return this._idMap;
     }
-    get sourced() {
-        return this._sourced;
-    }
-    /** Mark this file as being part of the dfg */
-    addFile(source) {
-        this._sourced.push(source);
-    }
     /**
      * Retrieves the set of vertices which have side effects that we do not know anything about.
      */
@@ -159,6 +157,15 @@ class DataflowGraph {
             }
         }
     }
+    *verticesOfType(type) {
+        const ids = this.types.get(type) ?? [];
+        for (const id of ids) {
+            yield [id, this.vertexInformation.get(id)];
+        }
+    }
+    vertexIdsOfType(type) {
+        return this.types.get(type) ?? [];
+    }
     /**
      * @returns the ids of all edges in the graph together with their edge information
      * @see #vertices
@@ -186,24 +193,32 @@ class DataflowGraph {
     /**
      * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
      * @param vertex - The vertex to add
+     * @param fallbackEnv - A clean environment to use if no environment is given in the vertex
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex, asRoot = true, overwrite = false) {
+    addVertex(vertex, fallbackEnv, asRoot = true, overwrite = false) {
         const oldVertex = this.vertexInformation.get(vertex.id);
         if (oldVertex !== undefined && !overwrite) {
             return this;
         }
-        const fallback = vertex.tag === vertex_1.VertexType.VariableDefinition || vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value || (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
+        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
         });
+        const has = this.types.get(vertex.tag);
+        if (has) {
+            has.push(vertex.id);
+        }
+        else {
+            this.types.set(vertex.tag, [vertex.id]);
+        }
         if (asRoot) {
             this.rootVertices.add(vertex.id);
         }
@@ -248,7 +263,6 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
-        this._sourced = this._sourced.concat(otherGraph.sourced);
         for (const unknown of otherGraph.unknownSideEffects) {
             this._unknownSideEffects.add(unknown);
         }
@@ -256,6 +270,10 @@ class DataflowGraph {
             const currentInfo = this.vertexInformation.get(id);
             this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
         }
+        for (const [type, ids] of otherGraph.types) {
+            const existing = this.types.get(type);
+            this.types.set(type, existing ? existing.concat(ids) : ids.slice());
+        }
         this.mergeEdges(otherGraph);
         return this;
     }
@@ -299,7 +317,10 @@ class DataflowGraph {
     updateToFunctionCall(info) {
         const vertex = this.getVertex(info.id, true);
         (0, assert_1.guard)(vertex !== undefined && (vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value), () => `node must be a use or value node for ${JSON.stringify(info.id)} to update it to a function call but is ${vertex?.tag}`);
+        const previousTag = vertex.tag;
         this.vertexInformation.set(info.id, { ...vertex, ...info, tag: vertex_1.VertexType.FunctionCall });
+        this.types.set(previousTag, (this.types.get(previousTag) ?? []).filter(id => id !== info.id));
+        this.types.set(vertex_1.VertexType.FunctionCall, (this.types.get(vertex_1.VertexType.FunctionCall) ?? []).concat([info.id]));
     }
     /** If you do not pass the `to` node, this will just mark the node as maybe */
     addControlDependency(from, to, when) {
@@ -348,8 +369,8 @@ class DataflowGraph {
             }
         }
         graph.edgeInformation = new Map(data.edgeInformation.map(([id, edges]) => [id, new Map(edges)]));
-        if (data.sourced) {
-            graph._sourced = data.sourced;
+        for (const unknown of data._unknownSideEffects) {
+            graph._unknownSideEffects.add(unknown);
         }
         return graph;
     }
@@ -386,14 +407,9 @@ function envFromJson(json) {
     for (const [key, value] of Object.entries(json.memory)) {
         memory.set(key, value);
     }
-    const obj = {
-        id: json.id,
-        parent: parent,
-        memory
-    };
-    if (json.builtInEnv) {
-        obj.builtInEnv = true;
-    }
+    const obj = new environment_1.Environment(parent, json.builtInEnv);
+    obj.id = json.id;
+    obj.memory = memory;
     return obj;
 }
 function renvFromJson(json) {

package/dataflow/graph/invert-dfg.d.ts

@@ -1,5 +1,6 @@
 import { DataflowGraph } from './graph';
+import type { REnvironmentInformation } from '../environments/environment';
 /**
- *
+ * Inverts the given dataflow graph by reversing all edges.
  */
-export declare function invertDfg(graph: DataflowGraph): DataflowGraph;
+export declare function invertDfg(graph: DataflowGraph, cleanEnv: REnvironmentInformation): DataflowGraph;

package/dataflow/graph/invert-dfg.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.invertDfg = invertDfg;
 const graph_1 = require("./graph");
 /**
- *
+ * Inverts the given dataflow graph by reversing all edges.
  */
-function invertDfg(graph) {
+function invertDfg(graph, cleanEnv) {
     const invertedGraph = new graph_1.DataflowGraph(graph.idMap);
     for (const [, v] of graph.vertices(true)) {
-        invertedGraph.addVertex(v);
+        invertedGraph.addVertex(v, cleanEnv);
     }
     for (const [from, targets] of graph.edges()) {
         for (const [to, { types }] of targets) {

package/dataflow/graph/resolve-graph.d.ts

@@ -1,7 +1,8 @@
 import { DataflowGraph } from './graph';
 import { type AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Resolves the dataflow graph ids from slicing criterion form to ids.
  * This returns a **new** graph with the resolved ids.
  */
-export declare function resolveDataflowGraph(graph: DataflowGraph, idMap?: AstIdMap): DataflowGraph;
+export declare function resolveDataflowGraph(graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap): DataflowGraph;

package/dataflow/graph/resolve-graph.js

@@ -9,7 +9,7 @@ const edge_1 = require("./edge");
  * Resolves the dataflow graph ids from slicing criterion form to ids.
  * This returns a **new** graph with the resolved ids.
  */
-function resolveDataflowGraph(graph, idMap) {
+function resolveDataflowGraph(graph, ctx, idMap) {
     const resolveMap = idMap ?? graph.idMap;
     (0, assert_1.guard)(resolveMap !== undefined, 'idMap must be provided to resolve the graph');
     const cache = new Map();
@@ -36,7 +36,7 @@ function resolveDataflowGraph(graph, idMap) {
         resultGraph.addVertex({
             ...vertex,
             id: resolve(id)
-        }, roots.has(id));
+        }, ctx.env.makeCleanEnv(), roots.has(id));
     }
     /* recreate edges */
     for (const [from, targets] of graph.edges()) {