@eagleoutice/flowr 1.5.2 → 2.0.0

package/dataflow/internal/linker.d.ts

@@ -1,26 +1,27 @@
-import type { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
-import type { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
 import { DefaultMap } from '../../util/defaultmap';
-import type { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
-export declare function linkIngoingVariablesInSameScope(graph: DataflowGraph, references: IdentifierReference[]): void;
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { IdentifierReference } from '../environments/identifier';
+import type { DataflowGraph, FunctionArgument } from '../graph/graph';
+import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
+import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowGraphVertexInfo } from '../graph/vertex';
+import type { REnvironmentInformation } from '../environments/environment';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
-export declare function linkReadVariablesInSameScopeWithNames(graph: DataflowGraph, nameIdShares: DefaultMap<string, IdentifierReference[]>): void;
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
  */
-export declare function linkFunctionCalls(graph: DataflowGraph, idMap: DecoratedAstMap, functionCalls: [NodeId, DataflowGraphVertexInfo][], thisGraph: DataflowGraph): {
+export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap, thisGraph: DataflowGraph): {
     functionCall: NodeId;
-    called: DataflowGraphVertexInfo[];
+    called: readonly DataflowGraphVertexInfo[];
 }[];
 export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: Set<NodeId>, dataflowGraph: DataflowGraph): Map<NodeId, DataflowGraphVertexInfo>;
 /**
  * This method links a set of read variables to definitions in an environment.
  *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
- * @param scope                              - The scope in which the linking shall happen (probably the active scope of {@link DataflowProcessorInformation})
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
@@ -28,7 +29,7 @@ export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadId
  *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
-export declare function linkInputs(referencesToLinkAgainstEnvironment: IdentifierReference[], scope: DataflowScopeName, environmentInformation: REnvironmentInformation, givenInputs: IdentifierReference[], graph: DataflowGraph, maybeForRemaining: boolean): IdentifierReference[];
+export declare function linkInputs(referencesToLinkAgainstEnvironment: readonly IdentifierReference[], environmentInformation: REnvironmentInformation, givenInputs: IdentifierReference[], graph: DataflowGraph, maybeForRemaining: boolean): IdentifierReference[];
 /** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
@@ -38,4 +39,4 @@ export declare function linkInputs(referencesToLinkAgainstEnvironment: Identifie
  * ```
  * `x_2` must get a read marker to `x_1` as `x_1` is the active redefinition in the second loop iteration.
  */
-export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openIns: NameIdMap, outgoing: IdentifierReference[]): void;
+export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openIns: NameIdMap, outgoing: readonly IdentifierReference[]): void;

package/dataflow/internal/linker.js

@@ -1,97 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkArgumentsOnCall = exports.linkReadVariablesInSameScopeWithNames = exports.produceNameSharedIdMap = exports.linkIngoingVariablesInSameScope = void 0;
-const environments_1 = require("../environments");
+exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkArgumentsOnCall = exports.produceNameSharedIdMap = void 0;
 const defaultmap_1 = require("../../util/defaultmap");
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
-const slicing_1 = require("../../slicing");
-const index_1 = require("../index");
-const scopes_1 = require("../environments/scopes");
-function linkIngoingVariablesInSameScope(graph, references) {
-    const nameIdShares = produceNameSharedIdMap(references);
-    linkReadVariablesInSameScopeWithNames(graph, nameIdShares);
-}
-exports.linkIngoingVariablesInSameScope = linkIngoingVariablesInSameScope;
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const graph_1 = require("../graph/graph");
+const logger_1 = require("../logger");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const edge_1 = require("../graph/edge");
+const resolve_by_name_1 = require("../environments/resolve-by-name");
+const built_in_1 = require("../environments/built-in");
+const static_slicer_1 = require("../../slicing/static/static-slicer");
 function produceNameSharedIdMap(references) {
     const nameIdShares = new defaultmap_1.DefaultMap(() => []);
     for (const reference of references) {
-        nameIdShares.get(reference.name).push(reference);
+        if (reference.name) {
+            nameIdShares.get(reference.name).push(reference);
+        }
     }
     return nameIdShares;
 }
 exports.produceNameSharedIdMap = produceNameSharedIdMap;
-function linkReadVariablesInSameScopeWithNames(graph, nameIdShares) {
-    for (const ids of nameIdShares.values()) {
-        if (ids.length <= 1) {
-            continue;
-        }
-        const base = ids[0];
-        for (let i = 1; i < ids.length; i++) {
-            graph.addEdge(base.nodeId, ids[i].nodeId, index_1.EdgeType.SameReadRead, 'always', true);
-        }
-    }
-}
-exports.linkReadVariablesInSameScopeWithNames = linkReadVariablesInSameScopeWithNames;
-function specialReturnFunction(info, graph, id) {
-    if (info.args.length > 1) {
-        index_1.dataflowLogger.error(`expected up to one argument for return, but got ${info.args.length}`);
-    }
-    for (const arg of info.args) {
-        if (Array.isArray(arg)) {
-            if (arg[1] !== '<value>') {
-                graph.addEdge(id, arg[1], index_1.EdgeType.Returns, 'always');
-            }
-        }
-        else if (arg !== '<value>') {
-            graph.addEdge(id, arg, index_1.EdgeType.Returns, 'always');
-        }
-    }
-}
 function linkArgumentsOnCall(args, params, graph) {
-    const nameArgMap = new Map(args.filter(Array.isArray));
+    const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
     const nameParamMap = new Map(params.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) {
-        if (arg === '<value>') {
-            index_1.dataflowLogger.trace(`skipping value argument for ${name}`);
-            continue;
-        }
         const param = nameParamMap.get(name);
         if (param !== undefined) {
-            index_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
-            graph.addEdge(arg.nodeId, param.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+            logger_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
+            graph.addEdge(arg.nodeId, param.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
             matchedParameters.add(name);
         }
         else if (specialDotParameter !== undefined) {
-            index_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
-            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+            logger_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
+            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
         }
     }
     const remainingParameter = params.filter(p => !matchedParameters.has(p.name.content));
-    const remainingArguments = args.filter(a => !Array.isArray(a));
+    const remainingArguments = args.filter(a => !(0, graph_1.isNamedArgument)(a));
     for (let i = 0; i < remainingArguments.length; i++) {
         const arg = remainingArguments[i];
-        if (arg === '<value>' || arg === 'empty') {
-            index_1.dataflowLogger.trace(`skipping value argument for ${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) {
-                index_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to dot-dot-dot parameter`);
-                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+                logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to dot-dot-dot parameter`);
+                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
             }
             else {
-                index_1.dataflowLogger.error(`skipping argument ${i} as there is no corresponding parameter - R should block that`);
+                logger_1.dataflowLogger.error(`skipping argument ${i} as there is no corresponding parameter - R should block that`);
             }
             continue;
         }
         const param = remainingParameter[i];
-        index_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name.content}"`);
-        graph.addEdge(arg.nodeId, param.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+        logger_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name.content}"`);
+        graph.addEdge(arg.nodeId, param.name.info.id, { type: 16 /* EdgeType.DefinesOnCall */ });
     }
 }
 exports.linkArgumentsOnCall = linkArgumentsOnCall;
@@ -99,42 +69,48 @@ 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) {
-        index_1.dataflowLogger.trace(`no function definition found for ${functionCallName} (${functionRootId})`);
+        logger_1.dataflowLogger.trace(`no function definition found for ${functionCallName} (${functionRootId})`);
         return;
     }
     if (linkedFunction.type !== "RFunctionDefinition" /* RType.FunctionDefinition */) {
-        index_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
+        logger_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
         return;
     }
-    index_1.dataflowLogger.trace(`linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
     linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
 function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions) {
-    const edges = graph.get(id, true);
-    (0, assert_1.guard)(edges !== undefined, () => `id ${id} must be present in graph`);
-    const functionDefinitionReadIds = [...edges[1]].filter(([_, e]) => e.types.has(index_1.EdgeType.Reads) || e.types.has(index_1.EdgeType.Calls) || e.types.has(index_1.EdgeType.Relates)).map(([target, _]) => target);
+    const edges = graph.outgoingEdges(id);
+    if (edges === undefined) {
+        /* no outgoing edges */
+        return;
+    }
+    const readBits = 1 /* EdgeType.Reads */ | 4 /* EdgeType.Calls */;
+    const functionDefinitionReadIds = [...edges].filter(([_, e]) => (0, edge_1.edgeDoesNotIncludeType)(e.types, 64 /* EdgeType.Argument */)
+        && (0, edge_1.edgeIncludesType)(e.types, readBits)).map(([target, _]) => target);
     const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
     for (const def of functionDefs.values()) {
-        (0, assert_1.guard)(def.tag === 'function-definition', () => `expected function definition, but got ${def.tag}`);
+        (0, assert_1.guard)(def.tag === "function-definition" /* VertexType.FunctionDefinition */, () => `expected function definition, but got ${def.tag}`);
         if (info.environment !== undefined) {
-            // for each open ingoing reference, try to resolve it here, and if so add a read edge from the call to signal that it reads it
+            // for each open ingoing reference, try to resolve it here, and if so, add a read edge from the call to signal that it reads it
             for (const ingoing of def.subflow.in) {
-                const defs = (0, environments_1.resolveByName)(ingoing.name, scopes_1.LocalScope, info.environment);
+                const defs = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, info.environment) : undefined;
                 if (defs === undefined) {
                     continue;
                 }
                 for (const def of defs) {
-                    graph.addEdge(id, def, index_1.EdgeType.Reads, 'always');
+                    graph.addEdge(id, def, { type: 1 /* EdgeType.Reads */ });
                 }
             }
         }
         const exitPoints = def.exitPoints;
         for (const exitPoint of exitPoints) {
-            graph.addEdge(id, exitPoint, index_1.EdgeType.Returns, 'always');
+            graph.addEdge(id, exitPoint, { type: 8 /* EdgeType.Returns */ });
         }
-        index_1.dataflowLogger.trace(`recording expression-list-level call from ${info.name} to ${def.name}`);
-        graph.addEdge(id, def.id, index_1.EdgeType.Calls, 'always');
-        linkFunctionCallArguments(def.id, idMap, def.name, id, info.args, graph);
+        const defName = (0, node_id_1.recoverName)(def.id, idMap);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `recording expression-list-level call from ${(0, node_id_1.recoverName)(info.id, idMap)} to ${defName}`);
+        graph.addEdge(id, def.id, { type: 4 /* EdgeType.Calls */ });
+        linkFunctionCallArguments(def.id, idMap, defName, id, info.args, graph);
     }
     if (thisGraph.isRoot(id)) {
         calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
@@ -144,15 +120,11 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
  */
-function linkFunctionCalls(graph, idMap, functionCalls, thisGraph) {
+function linkFunctionCalls(graph, idMap, thisGraph) {
+    const functionCalls = [...thisGraph.vertices(true)]
+        .filter(([_, info]) => info.tag === "function-call" /* VertexType.FunctionCall */);
     const calledFunctionDefinitions = [];
     for (const [id, info] of functionCalls) {
-        (0, assert_1.guard)(info.tag === 'function-call', () => `encountered non-function call in function call linkage ${JSON.stringify(info)}`);
-        if (info.name === 'return') {
-            specialReturnFunction(info, graph, id);
-            graph.addEdge(id, environments_1.BuiltIn, index_1.EdgeType.Calls, 'always');
-            continue;
-        }
         linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
     }
     return calledFunctionDefinitions;
@@ -164,25 +136,26 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
     const result = new Map();
     while (potential.length > 0) {
         const currentId = potential.pop();
-        if (currentId === environments_1.BuiltIn) {
+        if (currentId === built_in_1.BuiltIn) {
             // do not traverse builtins
-            slicing_1.slicerLogger.trace('skipping builtin function definition during collection');
+            static_slicer_1.slicerLogger.trace('skipping builtin function definition during collection');
             continue;
         }
         const currentInfo = dataflowGraph.get(currentId, true);
         if (currentInfo === undefined) {
-            slicing_1.slicerLogger.trace('skipping unknown link');
+            static_slicer_1.slicerLogger.trace('skipping unknown link');
             continue;
         }
         visited.add(currentId);
         const outgoingEdges = [...currentInfo[1]];
-        const returnEdges = outgoingEdges.filter(([_, e]) => e.types.has(index_1.EdgeType.Returns));
+        const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, 8 /* EdgeType.Returns */));
         if (returnEdges.length > 0) {
-            // only traverse return edges and do not follow calls etc. as this indicates that we have a function call which returns a result, and not the function call itself
+            // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
             potential.push(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
             continue;
         }
-        const followEdges = outgoingEdges.filter(([_, e]) => e.types.has(index_1.EdgeType.Reads) || e.types.has(index_1.EdgeType.DefinedBy) || e.types.has(index_1.EdgeType.DefinedByOnCall) || e.types.has(index_1.EdgeType.Relates));
+        const followBits = 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 32 /* EdgeType.DefinedByOnCall */;
+        const followEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, followBits));
         if (currentInfo[0].subflow !== undefined) {
             result.set(currentId, currentInfo[0]);
         }
@@ -196,7 +169,6 @@ exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
  * This method links a set of read variables to definitions in an environment.
  *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
- * @param scope                              - The scope in which the linking shall happen (probably the active scope of {@link DataflowProcessorInformation})
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
@@ -204,20 +176,20 @@ exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
  *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
-function linkInputs(referencesToLinkAgainstEnvironment, scope, environmentInformation, givenInputs, graph, maybeForRemaining) {
+function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation, givenInputs, graph, maybeForRemaining) {
     for (const bodyInput of referencesToLinkAgainstEnvironment) {
-        const probableTarget = (0, environments_1.resolveByName)(bodyInput.name, scope, environmentInformation);
+        const probableTarget = bodyInput.name ? (0, resolve_by_name_1.resolveByName)(bodyInput.name, environmentInformation) : undefined;
         if (probableTarget === undefined) {
-            log_1.log.trace(`found no target for ${bodyInput.name} in ${scope}`);
+            log_1.log.trace(`found no target for ${bodyInput.name}`);
             if (maybeForRemaining) {
-                bodyInput.used = 'maybe';
+                bodyInput.controlDependencies ??= [];
             }
             givenInputs.push(bodyInput);
         }
         else {
             for (const target of probableTarget) {
                 // we can stick with maybe even if readId.attribute is always
-                graph.addEdge(bodyInput, target, index_1.EdgeType.Reads, undefined, true);
+                graph.addEdge(bodyInput, target, { type: 1 /* EdgeType.Reads */ });
             }
         }
     }
@@ -239,13 +211,15 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
     // this implicitly assumes that the outgoing references are ordered
     const lastOutgoing = new Map();
     for (const out of outgoing) {
-        lastOutgoing.set(out.name, out);
+        if (out.name) {
+            lastOutgoing.set(out.name, out);
+        }
     }
     for (const [name, targets] of openIns.entries()) {
         for (const out of lastOutgoing.values()) {
             if (out.name === name) {
                 for (const target of targets) {
-                    graph.addEdge(target.nodeId, out.nodeId, index_1.EdgeType.Reads, 'maybe');
+                    graph.addEdge(target.nodeId, out.nodeId, { type: 1 /* EdgeType.Reads */ });
                 }
             }
         }

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

@@ -0,0 +1,6 @@
+import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+import type { AstIdMap, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { EmptyArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RUnnamedArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+export declare function toUnnamedArgument<OtherInfo>(node: RNode<OtherInfo & ParentInformation> | undefined, idMap: AstIdMap<OtherInfo>): RUnnamedArgument<OtherInfo & ParentInformation> | typeof EmptyArgument;
+export declare function wrapArgumentsUnnamed<OtherInfo>(nodes: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[], idMap: AstIdMap<OtherInfo>): ("<>" | import("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument").RArgument<OtherInfo & ParentInformation>)[];

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapArgumentsUnnamed = exports.toUnnamedArgument = void 0;
+const range_1 = require("../../../../../../util/range");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
+function toUnnamedArgument(node, idMap) {
+    if (node === undefined) {
+        return r_function_call_1.EmptyArgument;
+    }
+    const arg = {
+        type: "RArgument" /* RType.Argument */,
+        lexeme: node.lexeme ?? '',
+        // is this correct?
+        location: node.location ?? voidRange,
+        info: {
+            ...node.info,
+            id: node.info.id + '-arg'
+        },
+        name: undefined,
+        value: node
+    };
+    idMap.set(arg.info.id, node);
+    return arg;
+}
+exports.toUnnamedArgument = toUnnamedArgument;
+function wrapArgumentsUnnamed(nodes, idMap) {
+    return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === "RArgument" /* RType.Argument */ ? n : toUnnamedArgument(n, idMap));
+}
+exports.wrapArgumentsUnnamed = wrapArgumentsUnnamed;
+//# sourceMappingURL=make-argument.js.map

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

@@ -0,0 +1,3 @@
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+export declare function unpackArgument<OtherInfo>(arg: RFunctionArgument<OtherInfo>): RNode<OtherInfo> | undefined;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackArgument = void 0;
+const log_1 = require("../../../../../../util/log");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+function unpackArgument(arg) {
+    if (arg === r_function_call_1.EmptyArgument) {
+        log_1.log.trace('Argument is empty, skipping');
+        return undefined;
+    }
+    else if (arg.name !== undefined) {
+        log_1.log.trace(`Argument ${JSON.stringify(arg)} is not unnamed, skipping`);
+        return undefined;
+    }
+    return arg.value;
+}
+exports.unpackArgument = unpackArgument;
+//# sourceMappingURL=unpack-argument.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-access.d.ts

@@ -0,0 +1,9 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    treatIndicesAsString: boolean;
+}): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-access.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAccess = void 0;
+const assert_1 = require("../../../../../../util/assert");
+const known_call_handling_1 = require("../known-call-handling");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const environment_1 = require("../../../../../environments/environment");
+function processAccess(name, args, rootId, data, config) {
+    if (args.length < 2) {
+        logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const head = args[0];
+    (0, assert_1.guard)(head !== r_function_call_1.EmptyArgument, () => `Access ${name.content} has no source, impossible!`);
+    let fnCall;
+    if (!config.treatIndicesAsString) {
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    }
+    else {
+        const newArgs = [...args];
+        // if the argument is a symbol, we convert it to a string for this perspective
+        for (let i = 1; i < newArgs.length; i++) {
+            const arg = newArgs[i];
+            if (arg !== r_function_call_1.EmptyArgument && arg.value?.type === "RSymbol" /* RType.Symbol */) {
+                newArgs[i] = {
+                    ...arg,
+                    value: {
+                        type: "RString" /* RType.String */,
+                        info: arg.value.info,
+                        lexeme: arg.value.lexeme,
+                        location: arg.value.location,
+                        content: {
+                            quotes: 'none',
+                            str: arg.value.lexeme
+                        }
+                    }
+                };
+            }
+        }
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data });
+    }
+    const info = fnCall.information;
+    info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, { type: 8 /* EdgeType.Returns */ });
+    /* access always reads all of its indices */
+    for (const arg of fnCall.processedArguments) {
+        if (arg !== undefined) {
+            info.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+        }
+        if (config.treatIndicesAsString) {
+            // everything but the first is disabled here
+            break;
+        }
+    }
+    return {
+        ...info,
+        /*
+     * Keep active nodes in case of assignments etc.
+     * We make them maybe as a kind of hack.
+     * This way when using
+     * ```ts
+     * a[[1]] <- 3
+     * a[[2]] <- 4
+     * a
+     * ```
+     * the read for a will use both accesses as potential definitions and not just the last one!
+     */
+        unknownReferences: (0, environment_1.makeAllMaybe)(info.unknownReferences, info.graph, info.environment, false),
+        entryPoint: rootId,
+        /** it is, to be precise, the accessed element we want to map to maybe */
+        in: info.in.map(ref => {
+            if (ref.nodeId === head.value?.info.id) {
+                return (0, environment_1.makeReferenceMaybe)(ref, info.graph, info.environment, false);
+            }
+            else {
+                return ref;
+            }
+        })
+    };
+}
+exports.processAccess = processAccess;
+//# sourceMappingURL=built-in-access.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.d.ts

@@ -0,0 +1,29 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export interface AssignmentConfiguration {
+    readonly superAssignment?: boolean;
+    readonly swapSourceAndTarget?: boolean;
+    readonly makeMaybe?: boolean;
+    readonly quoteSource?: boolean;
+    readonly canBeReplacement?: boolean;
+}
+/**
+ * Processes an assignment, i.e., `<target> <- <source>`.
+ * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
+ * This includes handling of replacement functions (e.g., `names(x) <- ...` as \`names&lt;-\` `(x, ...)`).
+ */
+export declare function processAssignment<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: AssignmentConfiguration): DataflowInformation;
+export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfiguration {
+    readonly name: RSymbol<OtherInfo & ParentInformation>;
+    readonly source: RNode<OtherInfo & ParentInformation>;
+    readonly args: [DataflowInformation, DataflowInformation];
+    readonly target: RSymbol<OtherInfo & ParentInformation>;
+    readonly rootId: NodeId;
+    readonly data: DataflowProcessorInformation<OtherInfo>;
+    readonly information: DataflowInformation;
+}