@eagleoutice/flowr 2.6.3 → 2.7.2

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,6 +72,7 @@ export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
     readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
+    readonly _unknownSideEffects: UnknownSideEffect[];
 }
 /**
  * An unknown side effect describes something that we cannot handle correctly (in all cases).
@@ -98,7 +100,6 @@ export type UnknownSideEffect = 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;
     private readonly _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
@@ -108,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
@@ -147,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
@@ -166,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,7 +51,6 @@ function getReferenceOfArgument(arg) {
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 class DataflowGraph {
-    static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
     /*
      * Set of vertices which have sideEffects that we do not know anything about.
@@ -60,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) */
@@ -69,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
@@ -150,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
@@ -177,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);
         }
@@ -246,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;
     }
@@ -289,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) {
@@ -338,6 +369,9 @@ class DataflowGraph {
             }
         }
         graph.edgeInformation = new Map(data.edgeInformation.map(([id, edges]) => [id, new Map(edges)]));
+        for (const unknown of data._unknownSideEffects) {
+            graph._unknownSideEffects.add(unknown);
+        }
         return graph;
     }
 }
@@ -373,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()) {

package/dataflow/graph/vertex.d.ts

@@ -7,9 +7,9 @@ import type { BuiltInMappingName } from '../environments/built-in';
 export declare enum VertexType {
     Value = "value",
     Use = "use",
-    FunctionCall = "function-call",
-    VariableDefinition = "variable-definition",
-    FunctionDefinition = "function-definition"
+    FunctionCall = "fcall",
+    VariableDefinition = "vdef",
+    FunctionDefinition = "fdef"
 }
 export declare const ValidVertexTypes: Set<string>;
 export declare const ValidVertexTypeReverse: {

package/dataflow/graph/vertex.js

@@ -14,9 +14,9 @@ var VertexType;
 (function (VertexType) {
     VertexType["Value"] = "value";
     VertexType["Use"] = "use";
-    VertexType["FunctionCall"] = "function-call";
-    VertexType["VariableDefinition"] = "variable-definition";
-    VertexType["FunctionDefinition"] = "function-definition";
+    VertexType["FunctionCall"] = "fcall";
+    VertexType["VariableDefinition"] = "vdef";
+    VertexType["FunctionDefinition"] = "fdef";
 })(VertexType || (exports.VertexType = VertexType = {}));
 exports.ValidVertexTypes = new Set(Object.values(VertexType));
 exports.ValidVertexTypeReverse = Object.fromEntries(Object.entries(VertexType).map(([k, v]) => [v, k]));

package/dataflow/info.d.ts

@@ -102,7 +102,7 @@ export interface DataflowInformation extends DataflowCfgInformation {
  * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
  * @see {@link DataflowInformation}
  */
-export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'builtInEnvironment' | 'completeAst'>): DataflowInformation;
+export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).

package/dataflow/internal/linker.d.ts

@@ -19,6 +19,8 @@ export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
 /**
  * Links the given arguments to the given parameters within the given graph.
+ * This follows the `pmatch` semantics of R
+ * @see https://cran.r-project.org/doc/manuals/R-lang.html#Argument-matching
  */
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
 /**

package/dataflow/internal/linker.js

@@ -29,9 +29,7 @@ const prefix_1 = require("../../util/prefix");
  */
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
-    const ids = new Set(graph.vertices(true)
-        .filter(([_, info]) => info.tag === vertex_1.VertexType.Use || info.tag === vertex_1.VertexType.FunctionCall)
-        .map(([id, _]) => id));
+    const ids = new Set(graph.vertexIdsOfType(vertex_1.VertexType.Use).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
     for (const id of ids) {
@@ -81,27 +79,28 @@ function produceNameSharedIdMap(references) {
 }
 /**
  * Links the given arguments to the given parameters within the given graph.
+ * This follows the `pmatch` semantics of R
+ * @see https://cran.r-project.org/doc/manuals/R-lang.html#Argument-matching
  */
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
-    const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined).map(p => [p.name.content, p]));
+    const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined)
+        .map(p => [p.name.content, p]));
     const specialDotParameter = params.find(p => p.special);
     // all parameters matched by name
     const matchedParameters = new Set();
     // first map names
-    for (const [name, arg] of nameArgMap) {
+    for (const [name, { nodeId: argId }] of nameArgMap) {
         const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, nameParamMap.keys()) ?? name;
         const param = nameParamMap.get(pmatchName);
         if (param?.name) {
-            logger_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
-            graph.addEdge(arg.nodeId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
-            graph.addEdge(param.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+            graph.addEdge(argId, param.name.info.id, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(param.name.info.id, argId, edge_1.EdgeType.DefinedByOnCall);
             matchedParameters.add(name);
         }
         else if (specialDotParameter?.name) {
-            logger_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
-            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
-            graph.addEdge(specialDotParameter.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
+            graph.addEdge(argId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
+            graph.addEdge(specialDotParameter.name.info.id, argId, edge_1.EdgeType.DefinedByOnCall);
         }
     }
     const remainingParameter = params.filter(p => !p?.name || !matchedParameters.has(p.name.content));
@@ -109,12 +108,10 @@ function linkArgumentsOnCall(args, params, graph) {
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
         if (arg === r_function_call_1.EmptyArgument) {
-            logger_1.dataflowLogger.trace(`skipping value argument for ${i}`);
             continue;
         }
         if (remainingParameter.length <= i) {
             if (specialDotParameter !== undefined) {
-                logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to dot-dot-dot parameter`);
                 graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, edge_1.EdgeType.DefinesOnCall);
                 graph.addEdge(specialDotParameter.name.info.id, arg.nodeId, edge_1.EdgeType.DefinedByOnCall);
             }
@@ -135,14 +132,13 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
     // we get them by just choosing the rhs of the definition
     const linkedFunction = idMap.get(targetId);
     if (linkedFunction === undefined) {
-        logger_1.dataflowLogger.trace(`no function definition found for ${functionCallName} (${functionRootId})`);
+        logger_1.dataflowLogger.trace(`no fdef found for ${functionCallName} (${functionRootId})`);
         return;
     }
     if (linkedFunction.type !== type_1.RType.FunctionDefinition) {
         logger_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
         return;
     }
-    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
     linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
 /**
@@ -202,10 +198,8 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
     const calledFunctionDefinitions = [];
-    for (const [id, info] of thisGraph.vertices(true)) {
-        if (info.tag === vertex_1.VertexType.FunctionCall) {
-            linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
-        }
+    for (const [id, info] of thisGraph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
+        linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
     }
     return calledFunctionDefinitions;
 }

package/dataflow/internal/process/functions/call/argument/unpack-argument.d.ts

@@ -2,5 +2,11 @@ import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 /**
  * Retrieve the value from an argument, if it is not empty.
+ * @see {@link unpackArg} - to specifically retrieve non-named arguments
  */
-export declare function unpackArgument<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined, noNameOnly?: boolean): RNode<OtherInfo> | undefined;
+export declare function unpackNonameArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
+/**
+ * Retrieve the value from a non-named argument, if it is not empty.
+ * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
+ */
+export declare function unpackArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;

package/dataflow/internal/process/functions/call/argument/unpack-argument.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unpackArgument = unpackArgument;
+exports.unpackNonameArg = unpackNonameArg;
+exports.unpackArg = unpackArg;
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * Retrieve the value from an argument, if it is not empty.
+ * @see {@link unpackArg} - to specifically retrieve non-named arguments
  */
-function unpackArgument(arg, noNameOnly = true) {
-    return arg === undefined || arg === r_function_call_1.EmptyArgument || (noNameOnly && arg.name) ? undefined : arg.value;
+function unpackNonameArg(arg) {
+    return arg === r_function_call_1.EmptyArgument || arg?.name !== undefined ? undefined : arg?.value;
+}
+/**
+ * Retrieve the value from a non-named argument, if it is not empty.
+ * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
+ */
+function unpackArg(arg) {
+    return arg === r_function_call_1.EmptyArgument ? undefined : arg?.value;
 }
 //# sourceMappingURL=unpack-argument.js.map