@eagleoutice/flowr 2.9.13 → 2.10.1

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,60 @@
+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';
+import { DefaultMap } from '../../util/collections/defaultmap';
+/**
+ * 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 underlying 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: <G extends DataflowGraph>(this: void, left: NamedGraph<G>, right: NamedGraph<G>, config?: Partial<GenericDiffConfiguration>) => GraphDifferenceReport;
+    /**
+     * Inverts the given dataflow graph by reversing all edges.
+     */
+    readonly invertGraph: <G extends DataflowGraph>(this: void, graph: G, cleanEnv: REnvironmentInformation) => G;
+    /**
+     * 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: <G extends DataflowGraph>(graph: G, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap) => G;
+    /**
+     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
+     */
+    readonly reaches: <G extends DataflowGraph>(this: void, from: NodeId, to: NodeId, graph: G, knownReachability?: DefaultMap<NodeId, Set<NodeId>>) => boolean;
+};

package/dataflow/graph/graph-helper.js

@@ -0,0 +1,128 @@
+"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");
+const defaultmap_1 = require("../../util/collections/defaultmap");
+/**
+ * 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 underlying 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.SlicingCriterion.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;
+    },
+    /**
+     * Determines whether there is a path from `from` to `to` in the given graph (via any edge type, only respecting direction)
+     */
+    reaches(from, to, graph, knownReachability = new defaultmap_1.DefaultMap(() => new Set())) {
+        const visited = new Set();
+        const toVisit = [from];
+        while (toVisit.length > 0) {
+            const currentId = toVisit.pop();
+            if (visited.has(currentId)) {
+                continue;
+            }
+            if (currentId === to || knownReachability.get(currentId).has(to)) {
+                knownReachability.get(from).add(to);
+                return true;
+            }
+            visited.add(currentId);
+            for (const [tar] of graph.outgoingEdges(currentId) ?? []) {
+                toVisit.push(tar);
+            }
+        }
+        return false;
+    },
+};
+//# sourceMappingURL=graph-helper.js.map

package/dataflow/graph/graph.d.ts

@@ -25,6 +25,7 @@ export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'
  */
 export interface NamedFunctionArgument extends IdentifierReference {
     readonly name: string;
+    readonly valueId: NodeId | undefined;
 }
 /**
  * A reference which does not have a name, like the references to the arguments `3` and `2` in the following:
@@ -32,7 +33,6 @@ export interface NamedFunctionArgument extends IdentifierReference {
  * ```r
  * foo(3, 2)
  * ```
- * @see #isPositionalArgument
  * @see NamedFunctionArgument
  */
 export interface PositionalFunctionArgument extends Omit<IdentifierReference, 'name'> {
@@ -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
@@ -94,16 +95,29 @@ export declare const FunctionArgument: {
      * @see {@link FunctionArgument.isEmpty}
      */
     readonly isNotEmpty: <T>(this: void, arg: T) => arg is Exclude<T, typeof EmptyArgument>;
+    /**
+     * Returns the id of a non-empty argument.
+     * @example
+     * ```r
+     * foo(a=3, 2) # returns the node id of either `a` or `2`
+     * ```
+     * @see {@link FunctionArgument.getReference}
+     */
+    readonly getId: (this: void, arg: FunctionArgument) => NodeId | undefined;
     /**
      * Returns the reference of a non-empty argument.
      * @example
      * ```r
      * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
      * ```
+     * @see {@link FunctionArgument.getId}
      */
     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 +152,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.
@@ -254,8 +269,9 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
+     * @param sourceIds - The id of the source vertex of the def, if available
      */
-    setDefinitionOfVertex(reference: IdentifierReference): void;
+    setDefinitionOfVertex(reference: IdentifierReference, sourceIds: readonly NodeId[] | undefined): void;
     /**
      * Marks a vertex in the graph to be a function call with the new information
      * @param info - The information about the new function call node

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
@@ -67,20 +68,41 @@ exports.FunctionArgument = {
         return arg !== r_function_call_1.EmptyArgument;
     },
     /**
-     * Returns the reference of a non-empty argument.
+     * Returns the id of a non-empty argument.
      * @example
      * ```r
-     * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
+     * foo(a=3, 2) # returns the node id of either `a` or `2`
      * ```
+     * @see {@link FunctionArgument.getReference}
      */
-    getReference(arg) {
+    getId(arg) {
         if (arg !== r_function_call_1.EmptyArgument) {
             return arg?.nodeId;
         }
         return undefined;
     },
+    /**
+     * Returns the reference of a non-empty argument.
+     * @example
+     * ```r
+     * foo(a=3, 2) # returns the node id of either `3` or `2`, but skips a
+     * ```
+     * @see {@link FunctionArgument.getId}
+     */
+    getReference(arg) {
+        if (arg === r_function_call_1.EmptyArgument) {
+            return undefined;
+        }
+        else if (arg.name === undefined) {
+            return arg.nodeId;
+        }
+        return arg.valueId;
+    },
     /**
      * 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 +111,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.
@@ -364,8 +387,9 @@ class DataflowGraph {
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
+     * @param sourceIds - The id of the source vertex of the def, if available
      */
-    setDefinitionOfVertex(reference) {
+    setDefinitionOfVertex(reference, sourceIds) {
         const vertex = this.getVertex(reference.nodeId);
         (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) {
@@ -374,6 +398,9 @@ class DataflowGraph {
         else {
             const oldTag = vertex.tag;
             vertex.tag = vertex_1.VertexType.VariableDefinition;
+            if (sourceIds) {
+                vertex.source = sourceIds;
+            }
             this.types.set(oldTag, (this.types.get(oldTag) ?? []).filter(id => id !== reference.nodeId));
             this.types.set(vertex_1.VertexType.VariableDefinition, (this.types.get(vertex_1.VertexType.VariableDefinition) ?? []).concat([reference.nodeId]));
         }

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",
@@ -123,6 +123,8 @@ export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVert
     readonly environment?: undefined;
     /** Indicates whether the variable definition is a *partial* definition (e.g,. in `x[a] <- b`) */
     readonly par?: true;
+    /** Points to the source ids of the "value" if there is one, this is more of a best-effort flag and not guaranteed to be there */
+    readonly source?: readonly NodeId[];
 }
 /**
  * Arguments required to construct a vertex which represents the definition of a function in the {@link DataflowGraph|dataflow graph}.

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.
  */