@eagleoutice/flowr 2.8.6 → 2.8.8

package/dataflow/eval/values/sets/set-constants.d.ts

@@ -1,10 +1,12 @@
 import { type Lift, type Value, type ValueSet, Top } from '../r-value';
 /**
- *
+ * Creates a value set from the given elements.
+ * @see {@link isSet} - to check whether a value is a set
  */
 export declare function setFrom<V extends Value[]>(...elements: V): Lift<ValueSet<Value[]>>;
 /**
- *
+ * Checks, whether the given value is a set.
+ * @see {@link setFrom} - to create sets
  */
 export declare function isSet<V extends Value>(element: V): boolean;
 export declare const ValueEmptySet: Lift<ValueSet<Value[]>>;

package/dataflow/eval/values/sets/set-constants.js

@@ -11,7 +11,8 @@ function flattenSetElements(s) {
     });
 }
 /**
- *
+ * Creates a value set from the given elements.
+ * @see {@link isSet} - to check whether a value is a set
  */
 function setFrom(...elements) {
     const vals = elements.flatMap(e => {
@@ -23,7 +24,8 @@ function setFrom(...elements) {
     };
 }
 /**
- *
+ * Checks, whether the given value is a set.
+ * @see {@link setFrom} - to create sets
  */
 function isSet(element) {
     return element.type === 'set';

package/dataflow/extractor.js

@@ -114,7 +114,7 @@ function produceDataFlowGraph(parser, completeAst, ctx) {
         completeAst,
         environment: ctx.env.makeCleanEnv(),
         processors: ctx.config.solver.instrument.dataflowExtractors?.(exports.processors, ctx) ?? exports.processors,
-        controlDependencies: undefined,
+        cds: undefined,
         referenceChain: [files[0].filePath],
         ctx
     };

package/dataflow/fn/exceptions-of-function.d.ts

@@ -3,7 +3,7 @@ import type { CallGraph } from '../graph/call-graph';
 import type { ControlDependency } from '../info';
 export interface ExceptionPoint {
     id: NodeId;
-    cds?: readonly ControlDependency[] | undefined;
+    cds?: readonly ControlDependency[];
 }
 /**
  * Collect exception sources of a function in the call graph.

package/dataflow/fn/exceptions-of-function.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateExceptionsOfFunction = calculateExceptionsOfFunction;
 const vertex_1 = require("../graph/vertex");
 const built_in_1 = require("../environments/built-in");
-const CatchHandlers = new Set(['builtin:try']);
+const CatchHandlers = new Set([built_in_1.BuiltInProcName.Try]);
 /**
  * Collect exception sources of a function in the call graph.
  * This returns the `NodeId`s of functions that may throw exceptions when called by the given function.
@@ -28,8 +28,8 @@ function calculateExceptionsOfFunction(id, graph) {
         }
         if (vtx.tag === vertex_1.VertexType.FunctionDefinition) {
             for (const e of vtx.exitPoints.filter(e => e.type === 4 /* ExitPointType.Error */)) {
-                if (!collectedExceptions.find(x => x.id === e.nodeId)) {
-                    collectedExceptions.push({ id: e.nodeId, cds: e.controlDependencies });
+                if (!collectedExceptions.some(x => x.id === e.nodeId)) {
+                    collectedExceptions.push({ id: e.nodeId, cds: e.cds });
                 }
             }
         }

package/dataflow/graph/call-graph.js

@@ -95,7 +95,7 @@ function computeCallGraph(graph) {
     return result;
 }
 function processCds(vtx, graph, result, state) {
-    for (const tar of vtx.controlDependencies ?? []) {
+    for (const tar of vtx.cds ?? []) {
         const targetVtx = graph.getVertex(tar.id, true);
         if (targetVtx) {
             processUnknown(targetVtx, undefined, graph, result, state);
@@ -186,7 +186,7 @@ function processCall(vtx, from, graph, result, state) {
                     tag: vertex_1.VertexType.FunctionCall,
                     name: name.lexeme,
                     onlyBuiltin: false,
-                    origin: ['function'],
+                    origin: [built_in_1.BuiltInProcName.Function],
                     args: []
                 }, oriVtx.environment);
             }

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

@@ -37,7 +37,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
     }, info?: {
         environment?: REnvironmentInformation;
         builtInEnvironment?: IEnvironment;
-        controlDependencies?: ControlDependency[];
+        cds?: ControlDependency[];
         readParams?: [NodeId, boolean][];
     }, asRoot?: boolean): this;
     /**
@@ -55,7 +55,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
         onlyBuiltIn?: boolean;
         environment?: REnvironmentInformation;
         builtInEnvironment?: IEnvironment;
-        controlDependencies?: ControlDependency[];
+        cds?: ControlDependency[];
         origin?: FunctionOriginInformation[];
         link?: DataflowGraphVertexAstLink;
         omitArgs?: boolean;
@@ -71,7 +71,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
      * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
      */
     defineVariable(id: NodeId, name?: string, info?: {
-        controlDependencies?: ControlDependency[];
+        cds?: ControlDependency[];
         definedBy?: NodeId[];
     }, asRoot?: boolean): this;
     /**
@@ -91,7 +91,7 @@ export declare class DataflowGraphBuilder<Vertex extends DataflowGraphVertexInfo
      * (i.e., be a valid entry point), or is it nested (e.g., as part of a function definition)
      */
     constant(id: NodeId, options?: {
-        controlDependencies?: ControlDependency[];
+        cds?: ControlDependency[];
     }, asRoot?: boolean): this;
     private edgeHelper;
     private queryHelper;

package/dataflow/graph/dataflowgraph-builder.js

@@ -54,14 +54,14 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
                 ...subflow,
                 entryPoint: (0, node_id_1.normalizeIdToNumberIfPossible)(subflow.entryPoint),
                 graph: new Set([...subflow.graph].map(node_id_1.normalizeIdToNumberIfPossible)),
-                out: subflow.out.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
-                in: subflow.in.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
-                unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), controlDependencies: o.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                out: subflow.out.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                in: subflow.in.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
+                unknownReferences: subflow.unknownReferences.map(o => ({ ...o, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(o.nodeId), cds: o.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) })),
                 hooks: subflow.hooks ?? []
             },
-            exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e.nodeId), controlDependencies: e.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }) :
-                ({ nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e), type: 0 /* ExitPointType.Default */, controlDependencies: undefined })),
-            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            exitPoints: exitPoints.map(e => typeof e === 'object' ? ({ ...e, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e.nodeId), cds: e.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })) }) :
+                ({ nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(e), type: 0 /* ExitPointType.Default */, cds: undefined })),
+            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
             environment: info?.environment,
         }, asRoot);
     }
@@ -80,11 +80,11 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             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 }),
+            args: args.map(a => a === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : { ...a, nodeId: (0, node_id_1.normalizeIdToNumberIfPossible)(a.nodeId), cds: undefined }),
             environment: (info?.onlyBuiltIn || onlyBuiltInAuto) ? undefined : info?.environment ?? this.defaultEnvironment,
-            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            cds: info?.cds?.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'],
+            origin: info?.origin ?? [(0, default_builtin_config_1.getDefaultProcessor)(name) ?? built_in_1.BuiltInProcName.Function],
             link: info?.link
         }, asRoot);
         if (!info?.omitArgs) {
@@ -116,7 +116,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
                 }
             }
             else if (!this.hasVertex(arg.nodeId, true)) {
-                this.use(arg.nodeId, arg.name, { cds: arg.controlDependencies });
+                this.use(arg.nodeId, arg.name, { cds: arg.cds });
                 this.argument(id, arg.nodeId);
             }
         }
@@ -134,7 +134,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             tag: vertex_1.VertexType.VariableDefinition,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
-            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
         }, asRoot);
         if (info?.definedBy) {
             for (const def of info.definedBy) {
@@ -156,11 +156,11 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
             tag: vertex_1.VertexType.Use,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
             name,
-            controlDependencies: undefined,
+            cds: undefined,
             environment: undefined
         }, {
             ...info,
-            controlDependencies: info?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
+            cds: info?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) }))
         }), asRoot);
     }
     /**
@@ -174,7 +174,7 @@ class DataflowGraphBuilder extends graph_1.DataflowGraph {
         return this.addVertexWithDefaultEnv({
             tag: vertex_1.VertexType.Value,
             id: (0, node_id_1.normalizeIdToNumberIfPossible)(id),
-            controlDependencies: options?.controlDependencies?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
+            cds: options?.cds?.map(c => ({ ...c, id: (0, node_id_1.normalizeIdToNumberIfPossible)(c.id) })),
             environment: undefined
         }, asRoot);
     }

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

@@ -130,7 +130,7 @@ function diffFunctionArguments(fn, a, b, ctx) {
             if (aArg.name !== bArg.name) {
                 ctx.report.addComment(`${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the name differs: ${aArg.name} vs ${bArg.name}.`);
             }
-            (0, info_1.diffControlDependencies)(aArg.controlDependencies, bArg.controlDependencies, { ...ctx, position: `${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the control dependency differs: ${JSON.stringify(aArg.controlDependencies)} vs ${JSON.stringify(bArg.controlDependencies)}.` });
+            (0, info_1.diffControlDependencies)(aArg.cds, bArg.cds, { ...ctx, position: `${ctx.position}In argument #${i} (of ${ctx.leftname}, unnamed) the control dependency differs: ${JSON.stringify(aArg.cds)} vs ${JSON.stringify(bArg.cds)}.` });
         }
     }
 }
@@ -168,7 +168,7 @@ function diffVertices(ctx) {
                 });
             }
         }
-        (0, info_1.diffControlDependencies)(lInfo.controlDependencies, rInfo.controlDependencies, { ...ctx, position: `Vertex ${id} differs in controlDependencies. ` });
+        (0, info_1.diffControlDependencies)(lInfo.cds, rInfo.cds, { ...ctx, position: `Vertex ${id} differs in cds. ` });
         if (lInfo.origin !== undefined || rInfo.origin !== undefined) {
             // compare arrays
             const equalArrays = lInfo.origin && rInfo.origin && (0, arrays_1.arrayEqual)(lInfo.origin, rInfo.origin);
@@ -216,7 +216,7 @@ function diffVertices(ctx) {
                     if (a.type !== b.type || a.nodeId !== b.nodeId) {
                         return false;
                     }
-                    (0, info_1.diffControlDependencies)(a.controlDependencies, b.controlDependencies, { ...ctx, position: '' });
+                    (0, info_1.diffControlDependencies)(a.cds, b.cds, { ...ctx, position: '' });
                     return true;
                 })) {
                     ctx.report.addComment(`Vertex ${id} differs in exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`, { tag: 'vertex', id });

package/dataflow/graph/graph.d.ts

@@ -105,7 +105,7 @@ 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;
+    private readonly types;
     toJSON(): DataflowGraphJson;
     /**
      * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.

package/dataflow/graph/graph.js

@@ -302,7 +302,7 @@ class DataflowGraph {
         const vertex = this.getVertex(reference.nodeId, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set reference`);
         if (vertex.tag === vertex_1.VertexType.FunctionDefinition || vertex.tag === vertex_1.VertexType.VariableDefinition) {
-            vertex.controlDependencies = reference.controlDependencies;
+            vertex.cds = reference.cds;
         }
         else {
             this.vertexInformation.set(reference.nodeId, { ...vertex, tag: vertex_1.VertexType.VariableDefinition });
@@ -327,17 +327,17 @@ class DataflowGraph {
         to = to ? (0, node_id_1.normalizeIdToNumberIfPossible)(to) : undefined;
         const vertex = this.getVertex(from, true);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
-        vertex.controlDependencies ??= [];
+        vertex.cds ??= [];
         if (to) {
             let hasControlDependency = false;
-            for (const { id, when: cond } of vertex.controlDependencies) {
+            for (const { id, when: cond } of vertex.cds) {
                 if (id === to && when !== cond) {
                     hasControlDependency = true;
                     break;
                 }
             }
             if (!hasControlDependency) {
-                vertex.controlDependencies.push({ id: to, when });
+                vertex.cds.push({ id: to, when });
             }
         }
         return this;

package/dataflow/graph/vertex.d.ts

@@ -3,7 +3,7 @@ import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph'
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ControlDependency, ExitPoint } from '../info';
-import type { BuiltInMappingName } from '../environments/built-in';
+import type { BuiltInProcName } from '../environments/built-in';
 export declare enum VertexType {
     Value = "value",
     Use = "use",
@@ -137,7 +137,7 @@ interface DataflowGraphVertexBase extends MergeableRecord {
     /**
      * @see {@link ControlDependency} - the collection of control dependencies which have an influence on whether the vertex is executed.
      */
-    controlDependencies: ControlDependency[] | undefined;
+    cds: ControlDependency[] | undefined;
     /**
      * this attribute links a vertex to indices (pointer links) it may be affected by or related to
      */
@@ -209,7 +209,7 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
     origin: FunctionOriginInformation[] | 'unnamed';
 }
 /** Describes the processor responsible for a function call */
-export type FunctionOriginInformation = BuiltInMappingName | string;
+export type FunctionOriginInformation = BuiltInProcName;
 /**
  * Arguments required to construct a vertex which represents the definition of a variable in the {@link DataflowGraph|dataflow graph}.
  * @see {@link isVariableDefinitionVertex} - to check if a vertex is a variable definition vertex

package/dataflow/info.d.ts

@@ -63,7 +63,7 @@ export interface ExitPoint {
      * (e.g., if the `return` is contained within an `if` statement).
      * @see {@link happensInEveryBranch} - to check whether control dependencies are exhaustive
      */
-    readonly controlDependencies?: ControlDependency[] | undefined;
+    readonly cds?: ControlDependency[];
 }
 /**
  * Adds all non-default exit points to the existing list and updates the `invertExitCds` accordingly.
@@ -131,13 +131,13 @@ export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId
  * the list contains a dependency on the `true` and on the `false` case).
  * @see {@link happensInEveryBranchSet} - for the set-based version
  */
-export declare function happensInEveryBranch(controlDependencies: readonly ControlDependency[] | undefined): boolean;
+export declare function happensInEveryBranch(cds: readonly ControlDependency[] | undefined): boolean;
 /**
  * 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).
  * @see {@link happensInEveryBranch} - for the array-based version
  */
-export declare function happensInEveryBranchSet(controlDependencies: ReadonlySet<ControlDependency> | undefined): boolean;
+export declare function happensInEveryBranchSet(cds: ReadonlySet<ControlDependency> | undefined): boolean;
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points

package/dataflow/info.js

@@ -37,7 +37,7 @@ function addNonDefaultExitPoints(existing, invertExitCds, activeCds, add) {
     if (toAdd.length === 0) {
         return;
     }
-    const invertedCds = toAdd.flatMap(e => e.controlDependencies?.filter(icd => !activeCds?.some(e => e.id === icd.id && e.when === icd.when)).map(negateControlDependency)).filter(assert_1.isNotUndefined);
+    const invertedCds = toAdd.flatMap(e => e.cds?.filter(icd => !activeCds?.some(e => e.id === icd.id && e.when === icd.when)).map(negateControlDependency)).filter(assert_1.isNotUndefined);
     existing.push(...toAdd);
     for (const icd of invertedCds) {
         if (!invertExitCds.some(e => e.id === icd.id && e.when === icd.when)) {
@@ -49,8 +49,8 @@ function addNonDefaultExitPoints(existing, invertExitCds, activeCds, add) {
  * Overwrites the existing exit points with the given ones, taking care of cds.
  */
 function overwriteExitPoints(existing, replace) {
-    const replaceCds = replace.flatMap(e => e.controlDependencies);
-    if (replaceCds.length === 0 || replaceCds.some(r => r === undefined) || happensInEveryBranch(replaceCds.filter(e => e !== undefined))) {
+    const replaceCds = replace.flatMap(e => e.cds);
+    if (replaceCds.length === 0 || replaceCds.includes(undefined) || happensInEveryBranch(replaceCds.filter(e => e !== undefined))) {
         return replace;
     }
     return existing.concat(replace);
@@ -77,14 +77,14 @@ function initializeCleanDataflowInformation(entryPoint, data) {
  * the list contains a dependency on the `true` and on the `false` case).
  * @see {@link happensInEveryBranchSet} - for the set-based version
  */
-function happensInEveryBranch(controlDependencies) {
+function happensInEveryBranch(cds) {
     /* this happens only when we have no idea and require more analysis */
-    return controlDependencies === undefined || (controlDependencies.length !== 0 && coversSet(controlDependencies));
+    return cds === undefined || (cds.length !== 0 && coversSet(cds));
 }
-function coversSet(controlDependencies) {
+function coversSet(cds) {
     const trues = new Set();
     const falses = new Set();
-    for (const { id, when } of controlDependencies) {
+    for (const { id, when } of cds) {
         if (when) {
             trues.add(id);
         }
@@ -99,8 +99,8 @@ function coversSet(controlDependencies) {
  * the list contains a dependency on the `true` and on the `false` case).
  * @see {@link happensInEveryBranch} - for the array-based version
  */
-function happensInEveryBranchSet(controlDependencies) {
-    return controlDependencies === undefined || (controlDependencies.size !== 0 && coversSet(controlDependencies));
+function happensInEveryBranchSet(cds) {
+    return cds === undefined || (cds.size !== 0 && coversSet(cds));
 }
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
@@ -110,10 +110,10 @@ function alwaysExits(data) {
     let cds = [];
     for (const e of data.exitPoints) {
         if (e.type !== 0 /* ExitPointType.Default */) {
-            if (e.controlDependencies === undefined) {
+            if (e.cds === undefined) {
                 return true;
             }
-            cds = cds.concat(e.controlDependencies);
+            cds = cds.concat(e.cds);
         }
     }
     return happensInEveryBranch(cds);

package/dataflow/internal/linker.d.ts

@@ -25,11 +25,20 @@ export declare function produceNameSharedIdMap(references: IdentifierReference[]
  * If you just want to match by name, use {@link pMatch}.
  */
 export declare function linkArgumentsOnCall(args: readonly FunctionArgument[], params: readonly RParameter<ParentInformation>[], graph: DataflowGraph): Map<NodeId, NodeId>;
+/**
+ * Returns all argument ids that map to the given target parameter id.
+ */
+export declare function getAllIdsWithTarget<Targets extends NodeId>(maps: Map<NodeId, Targets>, target: Targets): NodeId[];
+/**
+ * Inverts the argument to parameter map to a parameter to argument map.
+ */
+export declare function invertArgumentMap<Targets extends NodeId>(maps: Map<NodeId, Targets>): Map<Targets, NodeId[]>;
 /**
  * Links the given arguments to the given parameters within the given graph by name only.
  * @note
  * To obtain the arguments from a {@link RFunctionCall}[], either use {@link processAllArguments} (also available via {@link processKnownFunctionCall})
  * or convert them with {@link convertFnArguments}.
+ * You can use {@link getAllIdsWithTarget} to get all argument ids that map to a given parameter.
  */
 export declare function pMatch<Targets extends NodeId>(args: readonly FunctionArgument[], params: Record<string, Targets>): Map<NodeId, Targets>;
 /**

package/dataflow/internal/linker.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNonLocalReads = findNonLocalReads;
 exports.produceNameSharedIdMap = produceNameSharedIdMap;
 exports.linkArgumentsOnCall = linkArgumentsOnCall;
+exports.getAllIdsWithTarget = getAllIdsWithTarget;
+exports.invertArgumentMap = invertArgumentMap;
 exports.pMatch = pMatch;
 exports.linkFunctionCallWithSingleTarget = linkFunctionCallWithSingleTarget;
 exports.linkFunctionCalls = linkFunctionCalls;
@@ -131,11 +133,34 @@ function linkArgumentsOnCall(args, params, graph) {
     }
     return maps;
 }
+/**
+ * Returns all argument ids that map to the given target parameter id.
+ */
+function getAllIdsWithTarget(maps, target) {
+    return maps.entries().filter(([, v]) => v === target).map(([k]) => k).toArray();
+}
+/**
+ * Inverts the argument to parameter map to a parameter to argument map.
+ */
+function invertArgumentMap(maps) {
+    const inverted = new Map();
+    for (const [arg, param] of maps.entries()) {
+        const existing = inverted.get(param);
+        if (existing) {
+            existing.push(arg);
+        }
+        else {
+            inverted.set(param, [arg]);
+        }
+    }
+    return inverted;
+}
 /**
  * Links the given arguments to the given parameters within the given graph by name only.
  * @note
  * To obtain the arguments from a {@link RFunctionCall}[], either use {@link processAllArguments} (also available via {@link processKnownFunctionCall})
  * or convert them with {@link convertFnArguments}.
+ * You can use {@link getAllIdsWithTarget} to get all argument ids that map to a given parameter.
  */
 function pMatch(args, params) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
@@ -150,6 +175,7 @@ function pMatch(args, params) {
         const param = params[pmatchName];
         if (param) {
             maps.set(argId, param);
+            matchedParameters.add(name);
         }
         else if (sid) {
             maps.set(argId, sid);
@@ -297,7 +323,7 @@ function getAllFunctionCallTargets(call, graph, environment) {
         return [];
     }
     if (info.name !== undefined && (environment !== undefined || info.environment !== undefined)) {
-        const functionCallDefs = (0, resolve_by_name_1.resolveByName)(info.name, environment ?? info.environment, identifier_1.ReferenceType.Function)?.map(d => d.nodeId) ?? [];
+        const functionCallDefs = (0, resolve_by_name_1.resolveByName)(info.name, environment ?? info.environment, info.origin.includes(built_in_1.BuiltInProcName.S3Dispatch) ? identifier_1.ReferenceType.S3MethodPrefix : identifier_1.ReferenceType.Function)?.map(d => d.nodeId) ?? [];
         for (const [target, outgoingEdge] of outgoingEdges.entries()) {
             if ((0, edge_1.edgeIncludesType)(outgoingEdge.types, edge_1.EdgeType.Calls)) {
                 functionCallDefs.push(target);
@@ -375,7 +401,7 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
         if (probableTarget === undefined) {
             log_1.log.trace(`found no target for ${bodyInput.name}`);
             if (maybeForRemaining) {
-                bodyInput.controlDependencies ??= [];
+                bodyInput.cds ??= [];
             }
             givenInputs.push(bodyInput);
         }
@@ -430,17 +456,17 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
  */
 function reapplyLoopExitPoints(exits, references) {
     // just apply the cds of all exit points not already present
-    const exitCds = new Set(exits.flatMap(e => e.controlDependencies).filter(assert_1.isNotUndefined));
+    const exitCds = new Set(exits.flatMap(e => e.cds).filter(assert_1.isNotUndefined));
     for (const ref of references) {
         for (const cd of exitCds) {
             const { id: cId, when: cWhen } = cd;
-            if (ref.controlDependencies) {
-                if (!ref.controlDependencies?.find(c => c.id === cId && c.when === cWhen)) {
-                    ref.controlDependencies.push({ ...cd, byIteration: true });
+            if (ref.cds) {
+                if (!ref.cds?.find(c => c.id === cId && c.when === cWhen)) {
+                    ref.cds.push({ ...cd, byIteration: true });
                 }
             }
             else {
-                ref.controlDependencies = [{ ...cd, byIteration: true }];
+                ref.cds = [{ ...cd, byIteration: true }];
             }
         }
     }

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

@@ -15,7 +15,7 @@ const containers_1 = require("../../../../../../util/containers");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'table:assign' }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.TableAssignment }).information;
 }
 /**
  * Processes different types of access operations.
@@ -37,16 +37,16 @@ function processAccess(name, args, rootId, data, config) {
     let fnCall;
     if (head === r_function_call_1.EmptyArgument) {
         // in this case we may be within a pipe
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:access' });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_1.BuiltInProcName.Access });
     }
-    else if (!config.treatIndicesAsString) {
+    else if (config.treatIndicesAsString) {
+        fnCall = processStringBasedAccess(args, data, name, rootId, config);
+    }
+    else {
         /* within an access operation which treats its fields, we redefine the table assignment ':=' as a trigger if this is to be treated as a definition */
         // do we have a local definition that needs to be recovered?
         fnCall = processNumberBasedAccess(data, name, args, rootId, config, head);
     }
-    else {
-        fnCall = processStringBasedAccess(args, data, name, rootId, config);
-    }
     const info = fnCall.information;
     if (head !== r_function_call_1.EmptyArgument) {
         info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, edge_1.EdgeType.Returns);
@@ -100,19 +100,18 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
     data.environment.current.memory.set(':=', [{
             type: identifier_1.ReferenceType.BuiltInFunction,
             definedAt: tableAssignId,
-            controlDependencies: undefined,
+            cds: undefined,
             processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
-            config: {},
             name: ':=',
             nodeId: tableAssignId
         }]);
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:access' });
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_1.BuiltInProcName.Access });
     /* recover the environment */
     if (existing !== undefined) {
         data.environment.current.memory.set(':=', existing);
     }
     if (head.value && outInfo.definitionRootNodes.length > 0) {
-        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data);
+        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, cds: [] }, outInfo.definitionRootNodes, rootId, data);
     }
     if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(args, data, fnCall, rootId, true);
@@ -156,8 +155,13 @@ function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclus
  */
 function processStringBasedAccess(args, data, name, rootId, config) {
     const newArgs = symbolArgumentsToStrings(args);
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs,
-        origin: 'builtin:access'
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args: newArgs,
+        rootId,
+        data,
+        forceArgs: config.forceArgs,
+        origin: built_in_1.BuiltInProcName.Access
     });
     if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(newArgs, data, fnCall, rootId, false);

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

@@ -18,6 +18,6 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     readonly resolveValue?: boolean;
 }
 /**
- *
+ * Process an apply call like `vapply` or `mapply`.
  */
 export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;