@eagleoutice/flowr 2.9.12 → 2.9.14

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

@@ -1,17 +1,12 @@
 import { FunctionArgument, type OutgoingEdges } from './graph';
-import { type GenericDiffConfiguration, type GenericDifferenceInformation } from '../../util/diff';
+import { type GenericDifferenceInformation } from '../../util/diff';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { type GraphDiffContext, type NamedGraph, GraphDifferenceReport } from '../../util/diff-graph';
+import type { GraphDifferenceReport, GraphDiffContext } from '../../util/diff-graph';
 /**
- * Compare two dataflow graphs and return a report on the differences.
- * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
- * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+ * This is the underlying function to calculate the difference based on a given context.
+ * Use {@link Dataflow.diff} to calculate the diff of two graphs.
  */
-export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>): GraphDifferenceReport;
-/**
- * Checks whether two function argument lists are equal.
- */
-export declare function equalFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[]): boolean;
+export declare function diffDataflowGraph(ctx: GraphDiffContext): void;
 /**
  * Compares two function argument lists and reports differences.
  */

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
-exports.equalFunctionArguments = equalFunctionArguments;
+exports.diffDataflowGraph = diffDataflowGraph;
 exports.diffFunctionArguments = diffFunctionArguments;
 exports.diffVertices = diffVertices;
 exports.diffEdges = diffEdges;
@@ -16,20 +15,10 @@ const identifier_1 = require("../environments/identifier");
 const diff_2 = require("../environments/diff");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const info_1 = require("../info");
-const diff_graph_1 = require("../../util/diff-graph");
 /**
- * Compare two dataflow graphs and return a report on the differences.
- * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
- * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+ * This is the underlying function to calculate the difference based on a given context.
+ * Use {@link Dataflow.diff} to calculate the diff of two graphs.
  */
-function diffOfDataflowGraphs(left, right, config) {
-    if (left.graph === right.graph) {
-        return new diff_graph_1.GraphDifferenceReport();
-    }
-    const ctx = (0, diff_graph_1.initDiffContext)(left, right, config);
-    diffDataflowGraph(ctx);
-    return ctx.report;
-}
 function diffDataflowGraph(ctx) {
     diffRootVertices(ctx);
     diffVertices(ctx);
@@ -80,20 +69,6 @@ function diffFunctionArgumentsReferences(fn, a, b, ctx) {
     }
     (0, diff_2.diffIdentifierReferences)(a, b, ctx);
 }
-/**
- * Checks whether two function argument lists are equal.
- */
-function equalFunctionArguments(fn, a, b) {
-    const ctx = {
-        report: new diff_graph_1.GraphDifferenceReport(),
-        leftname: 'left',
-        rightname: 'right',
-        position: '',
-        config: {}
-    };
-    diffFunctionArguments(fn, a, b, ctx);
-    return ctx.report.isEqual();
-}
 /**
  * Compares two function argument lists and reports differences.
  */

package/dataflow/graph/edge.d.ts

@@ -59,6 +59,7 @@ type DfEdgeLike = {
  * Helper Functions to work with {@link DfEdge} and {@link EdgeType}.
  */
 export declare const DfEdge: {
+    readonly name: "DfEdge";
     /**
      * Takes joint edge types and returns their human-readable names.
      */

package/dataflow/graph/edge.js

@@ -48,6 +48,7 @@ const edgeTypeToHumanReadableName = new Map([
  * Helper Functions to work with {@link DfEdge} and {@link EdgeType}.
  */
 exports.DfEdge = {
+    name: 'DfEdge',
     /**
      * Takes joint edge types and returns their human-readable names.
      */

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

@@ -0,0 +1,55 @@
+import { df2quads } from './quads';
+import type { NamedGraph } from '../../util/diff-graph';
+import { GraphDifferenceReport } from '../../util/diff-graph';
+import type { GenericDiffConfiguration } from '../../util/diff';
+import { DataflowGraph } from './graph';
+import type { REnvironmentInformation } from '../environments/environment';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
+import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ * The underlying functions which work for any graph* like view
+ * **Please do not use this object directly but use the helpers**
+ * - {@link Dataflow}
+ * - {@link CallGraph}
+ */
+export declare const GraphHelper: {
+    /** Maps to the mermaid-centric visualization helper for dataflow graphs and their views */
+    readonly visualize: {
+        /**
+         * Mermaid rendering helper for dataflow graphs
+         * - {@link DataflowMermaid.url}, {@link DataflowMermaid.raw} - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
+         * - {@link DataflowMermaid.convert} - for the underyling transformation
+         * @see {@link DataflowMermaid}
+         */
+        readonly mermaid: {
+            readonly name: "DataflowMermaid";
+            readonly convert: (this: void, config: import("../../util/mermaid/dfg").MermaidGraphConfiguration) => {
+                string: string;
+                mermaid: import("../../util/mermaid/dfg").MermaidGraph;
+            };
+            readonly raw: (this: void, graph: DataflowGraph | import("../info").DataflowInformation, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean) => string;
+            readonly url: (this: void, graph: DataflowGraph | import("../info").DataflowInformation, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean) => string;
+        };
+        readonly quads: {
+            readonly convert: typeof df2quads;
+        };
+    };
+    /**
+     * Compare two dataflow graphs and return a report on the differences.
+     * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+     * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+     */
+    readonly diffGraphs: (this: void, left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>) => GraphDifferenceReport;
+    /**
+     * Inverts the given dataflow graph by reversing all edges.
+     */
+    readonly invertGraph: (this: void, graph: DataflowGraph, cleanEnv: REnvironmentInformation) => DataflowGraph;
+    /**
+     * Resolves the dataflow graph ids from slicing criterion form to ids.
+     * This returns a **new** graph with the resolved ids.
+     * The main use-case for this is testing - if you do not know/want to fix the specific id,
+     * you can use, e.g. `2@x` as a placeholder for the first x in the second line!
+     */
+    readonly resolveGraphCriteria: (graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap) => DataflowGraph;
+};

package/dataflow/graph/graph-helper.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphHelper = void 0;
+const dfg_1 = require("../../util/mermaid/dfg");
+const quads_1 = require("./quads");
+const diff_graph_1 = require("../../util/diff-graph");
+const diff_dataflow_graph_1 = require("./diff-dataflow-graph");
+const graph_1 = require("./graph");
+const assert_1 = require("../../util/assert");
+const parse_1 = require("../../slicing/criterion/parse");
+const edge_1 = require("./edge");
+/**
+ * The underlying functions which work for any graph* like view
+ * **Please do not use this object directly but use the helpers**
+ * - {@link Dataflow}
+ * - {@link CallGraph}
+ */
+exports.GraphHelper = {
+    /** Maps to the mermaid-centric visualization helper for dataflow graphs and their views */
+    visualize: {
+        /**
+         * Mermaid rendering helper for dataflow graphs
+         * - {@link DataflowMermaid.url}, {@link DataflowMermaid.raw} - to render the graph as a mermaid graph (e.g., in markdown or the mermaid live editor)
+         * - {@link DataflowMermaid.convert} - for the underyling transformation
+         * @see {@link DataflowMermaid}
+         */
+        mermaid: dfg_1.DataflowMermaid,
+        quads: { convert: quads_1.df2quads }
+    },
+    /**
+     * Compare two dataflow graphs and return a report on the differences.
+     * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+     * @see {@link diffOfControlFlowGraphs} - for control flow graphs
+     */
+    diffGraphs(left, right, config) {
+        if (left.graph === right.graph) {
+            return new diff_graph_1.GraphDifferenceReport();
+        }
+        const ctx = (0, diff_graph_1.initDiffContext)(left, right, config);
+        (0, diff_dataflow_graph_1.diffDataflowGraph)(ctx);
+        return ctx.report;
+    },
+    /**
+     * Inverts the given dataflow graph by reversing all edges.
+     */
+    invertGraph(graph, cleanEnv) {
+        const invertedGraph = new graph_1.DataflowGraph(graph.idMap);
+        for (const [, v] of graph.vertices(true)) {
+            invertedGraph.addVertex(v, cleanEnv);
+        }
+        for (const [from, targets] of graph.edges()) {
+            for (const [to, { types }] of targets) {
+                invertedGraph.addEdge(to, from, types);
+            }
+        }
+        return invertedGraph;
+    },
+    /**
+     * Resolves the dataflow graph ids from slicing criterion form to ids.
+     * This returns a **new** graph with the resolved ids.
+     * The main use-case for this is testing - if you do not know/want to fix the specific id,
+     * you can use, e.g. `2@x` as a placeholder for the first x in the second line!
+     */
+    resolveGraphCriteria(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();
+        const resolve = (id) => {
+            const cached = cache.get(id);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const resolved = parse_1.SingleSlicingCriterion.tryParse(id, resolveMap) ?? id;
+            cache.set(id, resolved);
+            return resolved;
+        };
+        const resultGraph = new graph_1.DataflowGraph(resolveMap);
+        const roots = graph.rootIds();
+        /* recreate vertices */
+        for (const [id, vertex] of graph.vertices(true)) {
+            resultGraph.addVertex({
+                ...vertex,
+                id: resolve(id)
+            }, ctx.env.makeCleanEnv(), roots.has(id));
+        }
+        /* recreate edges */
+        for (const [from, targets] of graph.edges()) {
+            for (const [to, info] of targets) {
+                for (const type of edge_1.DfEdge.splitTypes(info)) {
+                    resultGraph.addEdge(resolve(from), resolve(to), type);
+                }
+            }
+        }
+        for (const unknown of graph.unknownSideEffects) {
+            if (typeof unknown === 'object') {
+                resultGraph.markIdForUnknownSideEffects(resolve(unknown.id), unknown.linkTo);
+            }
+            else {
+                resultGraph.markIdForUnknownSideEffects(resolve(unknown));
+            }
+        }
+        return resultGraph;
+    }
+};
+//# sourceMappingURL=graph-helper.js.map

package/dataflow/graph/graph.d.ts

@@ -51,6 +51,7 @@ export type FunctionArgument = NamedFunctionArgument | PositionalFunctionArgumen
  * @see {@link EmptyArgument} - the marker for empty arguments
  */
 export declare const FunctionArgument: {
+    readonly name: "FunctionArgument";
     /**
      * Checks whether the given argument is a positional argument.
      * @example
@@ -104,6 +105,9 @@ export declare const FunctionArgument: {
     readonly getReference: (this: void, arg: FunctionArgument) => NodeId | undefined;
     /**
      * Checks whether the given argument is a named argument with the specified name.
+     * Please note that this only checks whether the name is exactly identical and not whether
+     * R's argument matching resolves to the correct argument.
+     * For this, please refer to the {@link pMatch} function!
      * @see {@link isNamed}
      */
     readonly hasName: (this: void, arg: FunctionArgument, name: string | undefined) => arg is NamedFunctionArgument;
@@ -138,7 +142,8 @@ export type UnknownSideEffect = NodeId | {
 };
 /**
  * The dataflow graph holds the dataflow information found within the given AST.
- * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
+ * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}.
+ * The helper object associated with the DFG is {@link Dataflow}.
  *
  * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
  * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.

package/dataflow/graph/graph.js

@@ -13,6 +13,7 @@ const clone_1 = require("../environments/clone");
  * @see {@link EmptyArgument} - the marker for empty arguments
  */
 exports.FunctionArgument = {
+    name: 'FunctionArgument',
     /**
      * Checks whether the given argument is a positional argument.
      * @example
@@ -81,6 +82,9 @@ exports.FunctionArgument = {
     },
     /**
      * Checks whether the given argument is a named argument with the specified name.
+     * Please note that this only checks whether the name is exactly identical and not whether
+     * R's argument matching resolves to the correct argument.
+     * For this, please refer to the {@link pMatch} function!
      * @see {@link isNamed}
      */
     hasName(arg, name) {
@@ -89,7 +93,8 @@ exports.FunctionArgument = {
 };
 /**
  * The dataflow graph holds the dataflow information found within the given AST.
- * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
+ * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}.
+ * The helper object associated with the DFG is {@link Dataflow}.
  *
  * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
  * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.
@@ -402,17 +407,17 @@ class DataflowGraph {
         to = node_id_1.NodeId.normalize(to);
         const vertex = this.getVertex(from);
         (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
-        vertex.cds ??= [];
-        let hasControlDependency = false;
-        for (const { id, when: cond } of vertex.cds) {
-            if (id === to && when !== cond) {
-                hasControlDependency = true;
-                break;
+        if (vertex.cds) {
+            for (const { id, when: cond } of vertex.cds) {
+                if (id === to && when !== cond) {
+                    return this;
+                }
             }
         }
-        if (!hasControlDependency) {
-            vertex.cds.push({ id: to, when });
+        else {
+            vertex.cds = [];
         }
+        vertex.cds.push({ id: to, when });
         return this;
     }
     /** Marks the given node as having unknown side effects */

package/dataflow/graph/vertex.d.ts

@@ -3,8 +3,8 @@ 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 { BuiltInProcName } from '../environments/built-in';
 import type { Identifier } from '../environments/identifier';
+import type { BuiltInProcName } from '../environments/built-in-proc-name';
 export declare enum VertexType {
     Value = "value",
     Use = "use",

package/dataflow/info.d.ts

@@ -125,11 +125,21 @@ export interface DataflowInformation extends DataflowCfgInformation {
     graph: DataflowGraph;
 }
 /**
- * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
- * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
- * @see {@link DataflowInformation}
+ * Helper object for {@link DataflowInformation}
  */
-export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
+export declare const DataflowInformation: {
+    readonly name: "DataflowInformation";
+    /**
+     * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
+     * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
+     * @see {@link DataflowInformation}
+     */
+    readonly initialize: <T>(this: void, entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, "environment" | "completeAst">) => DataflowInformation;
+    /**
+     * Type guard to check whether the given information is a {@link DataflowInformation}.
+     */
+    readonly is: (info: unknown) => info is 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/info.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowInformation = void 0;
 exports.negateControlDependency = negateControlDependency;
 exports.doesExitPointPropagateCalls = doesExitPointPropagateCalls;
 exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
 exports.overwriteExitPoints = overwriteExitPoints;
-exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
 exports.happensInEveryBranch = happensInEveryBranch;
 exports.happensInEveryBranchSet = happensInEveryBranchSet;
 exports.alwaysExits = alwaysExits;
@@ -56,22 +56,34 @@ function overwriteExitPoints(existing, replace) {
     return existing.concat(replace);
 }
 /**
- * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
- * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
- * @see {@link DataflowInformation}
+ * Helper object for {@link DataflowInformation}
  */
-function initializeCleanDataflowInformation(entryPoint, data) {
-    return {
-        unknownReferences: [],
-        in: [],
-        out: [],
-        environment: data.environment,
-        graph: new graph_1.DataflowGraph(undefined),
-        entryPoint,
-        exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */ }],
-        hooks: []
-    };
-}
+exports.DataflowInformation = {
+    name: 'DataflowInformation',
+    /**
+     * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
+     * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
+     * @see {@link DataflowInformation}
+     */
+    initialize(entryPoint, data) {
+        return {
+            unknownReferences: [],
+            in: [],
+            out: [],
+            environment: data.environment,
+            graph: new graph_1.DataflowGraph(undefined),
+            entryPoint,
+            exitPoints: [{ nodeId: entryPoint, type: 0 /* ExitPointType.Default */ }],
+            hooks: []
+        };
+    },
+    /**
+     * Type guard to check whether the given information is a {@link DataflowInformation}.
+     */
+    is(info) {
+        return typeof info === 'object' && info !== null && 'entryPoint' in info && 'exitPoints' in info && 'hooks' in info;
+    }
+};
 /**
  * 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

@@ -25,22 +25,26 @@ 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.
+ * @example
+ * ```ts
+ * const parameterSpec = {
+ *   'paramName':         'paramId',
+ *   'anotherParamName':  'anotherParamId',
+ *   // we recommend to always add '...' to your specification
+ *   // this way you can collect all arguments that could not be matched!
+ *   '...':               '...'
+ * } as const;
+ *
+ * const match = pMatch(convertFnArguments(args), parameterSpec);
+ * const addParam = match.get('paramId');
+ * ```
  * @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>;
+export declare function pMatch<Targets extends NodeId>(args: readonly FunctionArgument[], params: Record<string, Targets>): Map<Targets, NodeId[]>;
 /**
  * Links a function call with a single target function definition.
  */

package/dataflow/internal/linker.js

@@ -3,8 +3,6 @@ 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;
@@ -25,10 +23,10 @@ const edge_1 = require("../graph/edge");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../graph/vertex");
 const resolve_by_name_1 = require("../environments/resolve-by-name");
-const built_in_1 = require("../environments/built-in");
 const prefix_1 = require("../../util/prefix");
 const info_1 = require("../info");
 const unnamed_call_handling_1 = require("./process/functions/call/unnamed-call-handling");
+const built_in_proc_name_1 = require("../environments/built-in-proc-name");
 /**
  * Find all reads within the graph that do not reference a local definition in the graph.
  */
@@ -137,38 +135,37 @@ 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.
+ * @example
+ * ```ts
+ * const parameterSpec = {
+ *   'paramName':         'paramId',
+ *   'anotherParamName':  'anotherParamId',
+ *   // we recommend to always add '...' to your specification
+ *   // this way you can collect all arguments that could not be matched!
+ *   '...':               '...'
+ * } as const;
+ *
+ * const match = pMatch(convertFnArguments(args), parameterSpec);
+ * const addParam = match.get('paramId');
+ * ```
  * @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.FunctionArgument.isNamed).map(a => [a.name, a]));
     const maps = new Map();
+    function addToMaps(key, value) {
+        const e = maps.get(key);
+        if (e) {
+            e.push(value);
+        }
+        else {
+            maps.set(key, [value]);
+        }
+    }
     const sid = params['...'];
     const paramNames = Object.keys(params);
     // all parameters matched by name
@@ -178,11 +175,11 @@ function pMatch(args, params) {
         const pmatchName = (0, prefix_1.findByPrefixIfUnique)(name, paramNames) ?? name;
         const param = params[pmatchName];
         if (param) {
-            maps.set(argId, param);
+            addToMaps(param, argId);
             matchedParameters.add(name);
         }
         else if (sid) {
-            maps.set(argId, sid);
+            addToMaps(sid, argId);
         }
     }
     const remainingParameter = paramNames.filter(p => !matchedParameters.has(p));
@@ -195,13 +192,13 @@ function pMatch(args, params) {
         const aid = arg.nodeId;
         if (remainingParameter.length <= i) {
             if (sid) {
-                maps.set(aid, sid);
+                addToMaps(sid, aid);
             }
             continue;
         }
         const param = params[remainingParameter[i]];
         if (param) {
-            maps.set(aid, param);
+            addToMaps(param, aid);
         }
     }
     return maps;
@@ -342,8 +339,8 @@ function getAllFunctionCallTargets(call, graph, environment) {
     }
     if (environment !== undefined || info.environment !== undefined) {
         let functionCallDefs = [];
-        const refType = info.origin.includes(built_in_1.BuiltInProcName.S3Dispatch) ? identifier_1.ReferenceType.S3MethodPrefix :
-            info.origin.includes(built_in_1.BuiltInProcName.S7Dispatch) ? identifier_1.ReferenceType.S7MethodPrefix : identifier_1.ReferenceType.Function;
+        const refType = info.origin.includes(built_in_proc_name_1.BuiltInProcName.S3Dispatch) ? identifier_1.ReferenceType.S3MethodPrefix :
+            info.origin.includes(built_in_proc_name_1.BuiltInProcName.S7Dispatch) ? identifier_1.ReferenceType.S7MethodPrefix : identifier_1.ReferenceType.Function;
         if (info.name !== undefined && !identifier_1.Identifier.getName(info.name).startsWith(unnamed_call_handling_1.UnnamedFunctionCallPrefix)) {
             functionCallDefs = (0, resolve_by_name_1.resolveByName)(info.name, environment ?? info.environment, refType)?.map(d => d.nodeId) ?? [];
         }

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

@@ -8,13 +8,13 @@ const node_id_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/process
 const logger_1 = require("../../../../../logger");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../../../graph/edge");
-const built_in_1 = require("../../../../../environments/built-in");
 const built_in_assignment_1 = require("./built-in-assignment");
 const identifier_1 = require("../../../../../environments/identifier");
 const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
+const built_in_proc_name_1 = require("../../../../../environments/built-in-proc-name");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.TableAssignment }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_proc_name_1.BuiltInProcName.TableAssignment }).information;
 }
 /**
  * Processes different types of access operations.
@@ -36,7 +36,7 @@ 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: built_in_1.BuiltInProcName.Access });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_proc_name_1.BuiltInProcName.Access });
     }
     else if (config.treatIndicesAsString) {
         fnCall = processStringBasedAccess(args, data, name, rootId, config);
@@ -104,7 +104,7 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
             name: ':=',
             nodeId: tableAssignId
         }]);
-    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_1.BuiltInProcName.Access });
+    const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: built_in_proc_name_1.BuiltInProcName.Access });
     /* recover the environment */
     if (existing !== undefined) {
         data.environment.current.memory.set(':=', existing);
@@ -156,7 +156,7 @@ function processStringBasedAccess(args, data, name, rootId, config) {
         rootId,
         data,
         forceArgs: config.forceArgs,
-        origin: built_in_1.BuiltInProcName.Access
+        origin: built_in_proc_name_1.BuiltInProcName.Access
     });
 }
 //# sourceMappingURL=built-in-access.js.map