@eagleoutice/flowr 2.10.3 → 2.10.5

package/queries/catalog/input-sources-query/simple-input-classifier.d.ts

@@ -2,19 +2,20 @@ import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/nod
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 import type { MergeableRecord } from '../../../util/objects';
 import { Identifier } from '../../../dataflow/environments/identifier';
+import type { FlowrSearchLike } from '../../../search/flowr-search-builder';
 /**
  * Lattice flattening until we have a taint engine :)
  * Please note that the classifier considers this basis with a set-lift,
  * joining differing lattice elements.
  *
  *```
- *            [ Unknown ]
- *     /     /     |     \       \
- *[Param] [File] [Net] [Rand] [Scope]
- *     \     \    |      /      /
- *        [ DerivedConstant ]
- *               |
- *          [ Constant ]
+ *              [ Unknown ]
+ *                   |
+ * [Param] [File] [Net], ...
+ *                   |
+ *            [ DerivedConstant ]
+ *                   |
+ *              [ Constant ]
  *```
  *
  */
@@ -23,6 +24,14 @@ export declare enum InputType {
     File = "file",
     Network = "net",
     Random = "rand",
+    /** Calls to system/system2 and similar */
+    System = "system",
+    /** Calls to .C / Fortran interfaces (foreign function interfaces) */
+    Ffi = "ffi",
+    /** Language objects (quote/substitute/etc.) */
+    Lang = "lang",
+    /** Global options / option accessors (options, getOption) */
+    Options = "options",
     Constant = "const",
     /** Read from environment/call scope */
     Scope = "scope",
@@ -40,16 +49,24 @@ export declare enum InputTraceType {
     /** Not fully known origin */
     Unknown = "unknown"
 }
+/**
+ * Scalar R constant values representable in TypeScript.
+ * `null` corresponds to R's `NULL`.
+ * NA values are not included (they have no direct TS equivalent).
+ */
+export type ConstantValue = string | number | boolean | null;
 /**
  * Object attached to an input source
  * @see {@link InputSources}
  */
 export interface InputSource extends MergeableRecord {
     id: NodeId;
-    type: InputType[];
+    types: InputType[];
     trace: InputTraceType;
     /** if the trace is affected by control dependencies, they are classified too, this is a duplicate free array */
     cds?: InputType[];
+    /** the concrete scalar value when the source is a constant or a pure alias of one */
+    value?: ConstantValue;
 }
 /**
  * Map of input sources, keyed by the node id of the input source. Each input source is classified with an {@link InputSource} object.
@@ -59,34 +76,22 @@ export type InputSources = InputSource[];
  * This is either an {@link NodeId|id} of a known functions all of that category (e.g., you can issue a dependencies query before and then pass all
  * identified ids to this query here).
  */
-export type InputClassifierFunctionIdentifier = Identifier | NodeId;
+export type InputClassifierFunctionIdentifiers = readonly (Identifier | NodeId)[];
 /**
- * For the specifications of `pureFns` etc. please have a look at {@link InputClassifierFunctionIdentifier}.
+ * For the specifications of `pure` etc. please have a look at {@link InputClassifierFunctionIdentifiers}.
  */
-export interface InputClassifierConfig extends MergeableRecord {
+export interface InputClassifierConfig<Functions extends InputClassifierFunctionIdentifiers | FlowrSearchLike = readonly Identifier[] | FlowrSearchLike> extends Partial<Record<InputType, Functions>> {
     /**
      * Functions which are considered to be pure (i.e., deterministic, trusted, safe, idempotent on the lub of the input types)
      */
-    pureFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that read from the network
-     */
-    networkFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that produce a random value
-     * Note: may need to check with respect to seeded randomness
-     */
-    randomFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that read from the file system
-     */
-    readFileFns: readonly InputClassifierFunctionIdentifier[];
+    [InputTraceType.Pure]?: Functions;
 }
 /**
  * Takes the given id which is expected to either be:
  * - a function call - in this case all arguments are considered to be inputs (additionally to all read edges from the function call in the dataflow graph)
- * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you pased in.
+ * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you passed in.
  *
- * This method traces the dependencies in the dataflow graph using the specification of functions passed in
+ * This method traces the dependencies in the dataflow graph using the specification of functions passed in.
+ * For the scope escape analysis, pass on the full, non-reduced DFG as `fullDfg`.
  */
-export declare function classifyInput(id: NodeId, dfg: DataflowGraph, config: InputClassifierConfig): InputSources;
+export declare function classifyInput(id: NodeId, dfg: DataflowGraph, config: InputClassifierConfig<InputClassifierFunctionIdentifiers>, fullDfg?: DataflowGraph): InputSources;

package/queries/catalog/input-sources-query/simple-input-classifier.js

@@ -6,17 +6,110 @@ const graph_1 = require("../../../dataflow/graph/graph");
 const objects_1 = require("../../../util/objects");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const df_helper_1 = require("../../../dataflow/graph/df-helper");
+const edge_1 = require("../../../dataflow/graph/edge");
 const identifier_1 = require("../../../dataflow/environments/identifier");
 const assert_1 = require("../../../util/assert");
 const arrays_1 = require("../../../util/collections/arrays");
 const built_in_proc_name_1 = require("../../../dataflow/environments/built-in-proc-name");
+const record_1 = require("../../../util/record");
+const r_number_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-number");
+const r_string_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-string");
+const r_logical_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-logical");
+const r_symbol_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
+const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
+function isConstantLike(type) {
+    return type === InputType.Constant || type === InputType.DerivedConstant;
+}
+/** Returns the common value shared by all defined entries, or `undefined` if they disagree or all are `undefined`. */
+function singleValue(values) {
+    let result;
+    let seen = false;
+    for (const v of values) {
+        if (v === undefined) {
+            return undefined;
+        }
+        if (!seen) {
+            result = v;
+            seen = true;
+        }
+        else if (v !== result) {
+            return undefined;
+        }
+    }
+    return result;
+}
+/**
+ * Accumulates types, control-dependency types, values, and purity while traversing origin
+ * chains. Call {@link build} to produce the resulting {@link InputSource}.
+ */
+class ClassificationAccumulator {
+    types = [];
+    cds = [];
+    values = [];
+    allPure = true;
+    merge(c) {
+        this.types.push(...c.types);
+        this.values.push(c.value);
+        if (c.cds) {
+            this.cds.push(...c.cds);
+        }
+        if (c.trace !== InputTraceType.Pure) {
+            this.allPure = false;
+        }
+    }
+    pushUnknown() {
+        this.types.push(InputType.Unknown);
+        this.values.push(undefined);
+    }
+    build(id) {
+        const types = this.types.length === 0 ? [InputType.Unknown] : (0, arrays_1.uniqueArray)(this.types);
+        const trace = this.allPure ? InputTraceType.Pure : InputTraceType.Alias;
+        const src = { id, types, trace };
+        const cds = this.cds.length === 0 ? undefined : (0, arrays_1.uniqueArray)(this.cds);
+        if (cds) {
+            src.cds = cds;
+        }
+        if (types.every(isConstantLike)) {
+            const v = singleValue(this.values);
+            if (v !== undefined) {
+                src.value = v;
+            }
+        }
+        return src;
+    }
+}
 class InputClassifier {
     dfg;
     config;
     cache = new Map();
-    constructor(dfg, config) {
+    fullDfg;
+    constructor(dfg, config, fullDfg) {
         this.dfg = dfg;
         this.config = config;
+        this.fullDfg = fullDfg;
+    }
+    isDefinedByOnCall(id) {
+        const out = (this.fullDfg ?? this.dfg).outgoingEdges(id) ?? new Map();
+        return out.values().some(e => edge_1.DfEdge.includesType(e, edge_1.EdgeType.DefinedByOnCall));
+    }
+    extractConstantValue(id) {
+        const node = this.dfg.idMap?.get(id);
+        if (node === undefined) {
+            return undefined;
+        }
+        if (r_number_1.RNumber.is(node)) {
+            return node.content.num;
+        }
+        if (r_string_1.RString.is(node)) {
+            return node.content.str;
+        }
+        if (r_logical_1.RLogical.is(node)) {
+            return node.content;
+        }
+        if (r_symbol_1.RSymbol.is(node) && node.content === convert_values_1.RNull) {
+            return null;
+        }
+        return undefined;
     }
     classifyEntry(vertex) {
         const cached = this.cache.get(vertex.id);
@@ -24,10 +117,16 @@ class InputClassifier {
             return cached;
         }
         // insert temporary unknown to break cycles
-        this.cache.set(vertex.id, { id: vertex.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+        this.cache.set(vertex.id, { id: vertex.id, types: [InputType.Unknown], trace: InputTraceType.Unknown });
         switch (vertex.tag) {
-            case vertex_1.VertexType.Value:
-                return this.classifyCdsAndReturn(vertex, { id: vertex.id, type: [InputType.Constant], trace: InputTraceType.Unknown });
+            case vertex_1.VertexType.Value: {
+                const src = { id: vertex.id, types: [InputType.Constant], trace: InputTraceType.Unknown };
+                const v = this.extractConstantValue(vertex.id);
+                if (v !== undefined) {
+                    src.value = v;
+                }
+                return this.classifyCdsAndReturn(vertex, src);
+            }
             case vertex_1.VertexType.FunctionCall:
                 return this.classifyFunctionCall(vertex);
             case vertex_1.VertexType.VariableDefinition:
@@ -35,7 +134,7 @@ class InputClassifier {
             case vertex_1.VertexType.Use:
                 return this.classifyVariable(vertex);
             default:
-                return this.classifyCdsAndReturn(vertex, { id: vertex.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+                return this.classifyCdsAndReturn(vertex, { id: vertex.id, types: [InputType.Unknown], trace: InputTraceType.Unknown });
         }
     }
     classifyFunctionCall(call) {
@@ -57,20 +156,18 @@ class InputClassifier {
                 }
             }
         }
-        if (!matchesList(call, this.config.pureFns)) {
-            if (matchesList(call, this.config.readFileFns)) {
-                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.File], trace: InputTraceType.Unknown });
-            }
-            else if (matchesList(call, this.config.networkFns)) {
-                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Network], trace: InputTraceType.Unknown });
-            }
-            else if (matchesList(call, this.config.randomFns)) {
-                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Random], trace: InputTraceType.Unknown });
+        if (!matchesList(call, this.config.pure)) {
+            const types = [];
+            for (const [type, entry] of record_1.Record.entries(this.config)) {
+                if (record_1.Record.values(InputType).includes(type) && matchesList(call, entry)) {
+                    types.push(type);
+                }
             }
-            else {
+            if (types.length === 0) {
                 // if it is not pure, we cannot classify based on the inputs, in that case we do not know!
-                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+                types.push(InputType.Unknown);
             }
+            return this.classifyCdsAndReturn(call, { id: call.id, types, trace: InputTraceType.Unknown });
         }
         // Otherwise, classify by arguments; pure functions get Known/Pure handling
         const argTypes = [];
@@ -91,111 +188,98 @@ class InputClassifier {
             }
             const classified = this.classifyEntry(argVtx);
             // collect all observed types from this argument
-            argTypes.push(...classified.type);
+            argTypes.push(...classified.types);
             if (classified.cds) {
                 cdTypes.push(...classified.cds);
             }
         }
         const cds = cdTypes.length > 0 ? (0, arrays_1.uniqueArray)(cdTypes) : undefined;
         // all arguments only contain constant-like types -> derived constant
-        const allConstLike = argTypes.length > 0 && argTypes.every(t => t === InputType.Constant || t === InputType.DerivedConstant);
+        const allConstLike = argTypes.length > 0 && argTypes.every(isConstantLike);
         if (allConstLike) {
-            return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, type: [InputType.DerivedConstant], trace: InputTraceType.Pure, cds }));
+            return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, types: [InputType.DerivedConstant], trace: InputTraceType.Pure, cds }));
         }
         argTypes.push(InputType.DerivedConstant);
-        return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, type: (0, arrays_1.uniqueArray)(argTypes), trace: InputTraceType.Known, cds }));
+        return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, types: (0, arrays_1.uniqueArray)(argTypes), trace: InputTraceType.Known, cds }));
     }
     classifyVariable(vtx) {
         const origins = df_helper_1.Dataflow.origin(this.dfg, vtx.id);
         if (origins === undefined) {
-            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, types: this.isDefinedByOnCall(vtx.id) ? [InputType.Scope] : [InputType.Unknown], trace: InputTraceType.Unknown });
         }
-        const types = [];
-        const cds = [];
-        let allPure = true;
+        const acc = new ClassificationAccumulator();
         for (const o of origins) {
             if (o.type === 4 /* OriginType.ConstantOrigin */) {
-                types.push(InputType.DerivedConstant);
-                continue;
+                acc.types.push(InputType.DerivedConstant);
+                acc.values.push(this.extractConstantValue(o.id));
             }
-            if (o.type === 0 /* OriginType.ReadVariableOrigin */ || o.type === 1 /* OriginType.WriteVariableOrigin */) {
-                const v = this.dfg.getVertex(o.id);
-                if (v) {
-                    // if this is a variable definition that is a parameter, classify as Parameter
-                    if (v.tag === vertex_1.VertexType.VariableDefinition && this.dfg.idMap?.get(v.id)?.info.role === "param-n" /* RoleInParent.ParameterName */) {
-                        types.push(InputType.Parameter);
-                        continue;
-                    }
-                    const c = this.classifyEntry(v);
-                    types.push(...c.type);
-                    if (c.cds) {
-                        cds.push(...c.cds);
-                    }
-                    if (c.trace !== InputTraceType.Pure) {
-                        allPure = false;
-                    }
-                }
-                else {
-                    types.push(InputType.Unknown);
-                }
-                continue;
+            else if (o.type === 0 /* OriginType.ReadVariableOrigin */ || o.type === 1 /* OriginType.WriteVariableOrigin */) {
+                this.classifyVariableOrigin(o.id, acc);
             }
-            if (o.type === 2 /* OriginType.FunctionCallOrigin */ || o.type === 3 /* OriginType.BuiltInFunctionOrigin */) {
-                const v = this.dfg.getVertex(o.id);
-                if (v) {
-                    const c = this.classifyEntry(v);
-                    types.push(...c.type);
-                    if (c.cds) {
-                        cds.push(...c.cds);
-                    }
-                    if (c.trace !== InputTraceType.Pure) {
-                        allPure = false;
-                    }
-                }
-                else {
-                    types.push(InputType.Unknown);
-                }
-                continue;
+            else if (o.type === 2 /* OriginType.FunctionCallOrigin */ || o.type === 3 /* OriginType.BuiltInFunctionOrigin */) {
+                this.classifyByVertex(o.id, acc);
             }
-            // unknown origin type
-            types.push(InputType.Unknown);
+            else {
+                acc.pushUnknown();
+            }
+        }
+        return this.classifyCdsAndReturn(vtx, acc.build(vtx.id));
+    }
+    /**
+     * Resolves a variable definition or use origin, handling the special cases of
+     * scope-escaped variables (DefinedByOnCall) and parameter definitions.
+     */
+    classifyVariableOrigin(definitionId, acc) {
+        const v = this.dfg.getVertex(definitionId);
+        if (!v) {
+            acc.pushUnknown();
+            return;
+        }
+        // if the referenced definition is linked via defined-by-on-call to another
+        // id (e.g., a parameter linked to a caller argument), mark it as a Scope origin
+        if (this.isDefinedByOnCall(v.id)) {
+            acc.types.push(InputType.Scope);
+            acc.values.push(undefined);
+            acc.allPure = false;
+        }
+        // if this is a variable definition that is a parameter, classify as Parameter
+        if (v.tag === vertex_1.VertexType.VariableDefinition && this.dfg.idMap?.get(v.id)?.info.role === "param-n" /* RoleInParent.ParameterName */) {
+            acc.types.push(InputType.Parameter);
+            acc.values.push(undefined);
+            return;
+        }
+        acc.merge(this.classifyEntry(v));
+    }
+    classifyByVertex(id, acc) {
+        const v = this.dfg.getVertex(id);
+        if (v) {
+            acc.merge(this.classifyEntry(v));
+        }
+        else {
+            acc.pushUnknown();
         }
-        const t = types.length === 0 ? [InputType.Unknown] : (0, arrays_1.uniqueArray)(types);
-        const trace = allPure ? InputTraceType.Pure : InputTraceType.Alias;
-        return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: t, trace, cds: cds.length === 0 ? undefined : (0, arrays_1.uniqueArray)(cds) });
     }
     classifyVariableDefinition(vtx) {
         // parameter definitions are classified as Parameter
         if (this.dfg.idMap?.get(vtx.id)?.info.role === "param-n" /* RoleInParent.ParameterName */) {
-            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Parameter], trace: InputTraceType.Unknown });
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, types: [InputType.Parameter], trace: InputTraceType.Unknown });
         }
         const sources = vtx.source;
         if (sources === undefined || sources.length === 0) {
             // fallback to unknown if we cannot find the value
-            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, types: [InputType.Unknown], trace: InputTraceType.Unknown });
         }
-        const types = [];
-        const cds = [];
-        let allPure = true;
+        const acc = new ClassificationAccumulator();
         for (const tid of sources) {
             const tv = this.dfg.getVertex(tid);
             if (tv) {
-                const c = this.classifyEntry(tv);
-                types.push(...c.type);
-                if (c.cds) {
-                    cds.push(...c.cds);
-                }
-                if (c.trace !== InputTraceType.Pure) {
-                    allPure = false;
-                }
+                acc.merge(this.classifyEntry(tv));
             }
             else {
-                types.push(InputType.Unknown);
+                acc.pushUnknown();
             }
         }
-        const t = types.length === 0 ? [InputType.Unknown] : (0, arrays_1.uniqueArray)(types);
-        const trace = allPure ? InputTraceType.Pure : InputTraceType.Alias;
-        return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: t, trace, cds: cds.length === 0 ? undefined : (0, arrays_1.uniqueArray)(cds) });
+        return this.classifyCdsAndReturn(vtx, acc.build(vtx.id));
     }
     classifyCdsAndReturn(vtx, src) {
         if (vtx.cds) {
@@ -205,7 +289,7 @@ class InputClassifier {
                     return undefined;
                 }
                 const e = this.classifyEntry(cv);
-                return e.cds ? [...e.type, ...e.cds] : [...e.type];
+                return e.cds ? [...e.types, ...e.cds] : [...e.types];
             }).filter(assert_1.isNotUndefined).concat(src.cds ?? []));
             if (cds.length > 0) {
                 src.cds = cds;
@@ -224,13 +308,13 @@ class InputClassifier {
  * joining differing lattice elements.
  *
  *```
- *            [ Unknown ]
- *     /     /     |     \       \
- *[Param] [File] [Net] [Rand] [Scope]
- *     \     \    |      /      /
- *        [ DerivedConstant ]
- *               |
- *          [ Constant ]
+ *              [ Unknown ]
+ *                   |
+ * [Param] [File] [Net], ...
+ *                   |
+ *            [ DerivedConstant ]
+ *                   |
+ *              [ Constant ]
  *```
  *
  */
@@ -240,6 +324,14 @@ var InputType;
     InputType["File"] = "file";
     InputType["Network"] = "net";
     InputType["Random"] = "rand";
+    /** Calls to system/system2 and similar */
+    InputType["System"] = "system";
+    /** Calls to .C / Fortran interfaces (foreign function interfaces) */
+    InputType["Ffi"] = "ffi";
+    /** Language objects (quote/substitute/etc.) */
+    InputType["Lang"] = "lang";
+    /** Global options / option accessors (options, getOption) */
+    InputType["Options"] = "options";
     InputType["Constant"] = "const";
     /** Read from environment/call scope */
     InputType["Scope"] = "scope";
@@ -259,11 +351,11 @@ var InputTraceType;
     InputTraceType["Unknown"] = "unknown";
 })(InputTraceType || (exports.InputTraceType = InputTraceType = {}));
 function matchesList(fn, list) {
-    if (!list || list.length === 0) {
+    if (list === undefined || list.length === 0) {
         return false;
     }
     for (const id of list) {
-        if (fn.id === id || identifier_1.Identifier.matches(id, fn.name)) {
+        if (fn.id === id || (identifier_1.Identifier.is(id) && identifier_1.Identifier.matches(id, fn.name))) {
             return true;
         }
     }
@@ -272,16 +364,17 @@ function matchesList(fn, list) {
 /**
  * Takes the given id which is expected to either be:
  * - a function call - in this case all arguments are considered to be inputs (additionally to all read edges from the function call in the dataflow graph)
- * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you pased in.
+ * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you passed in.
  *
- * This method traces the dependencies in the dataflow graph using the specification of functions passed in
+ * This method traces the dependencies in the dataflow graph using the specification of functions passed in.
+ * For the scope escape analysis, pass on the full, non-reduced DFG as `fullDfg`.
  */
-function classifyInput(id, dfg, config) {
+function classifyInput(id, dfg, config, fullDfg) {
     const vtx = dfg.getVertex(id);
     if (!vtx) {
         return [];
     }
-    const c = new InputClassifier(dfg, config);
+    const c = new InputClassifier(dfg, config, fullDfg);
     if (vtx.tag === vertex_1.VertexType.FunctionCall) {
         const ret = [];
         const args = vtx.args;

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -24,7 +24,7 @@ import type { RUnaryOp } from './nodes/r-unary-op';
 import type { RBinaryOp } from './nodes/r-binary-op';
 import type { RPipe } from './nodes/r-pipe';
 import type { RDelimiter } from './nodes/info/r-delimiter';
-import type { ParentInformation } from './processing/decorate';
+import type { AstIdMap, ParentInformation } from './processing/decorate';
 import type { NodeId } from './processing/node-id';
 import type { OnEnter, OnExit } from './processing/visitor';
 import type { SingleOrArrayOrNothing } from '../../../../abstract-interpretation/normalized-ast-fold';
@@ -264,16 +264,16 @@ export declare const RNode: {
      * linear chain of parents leading to the root node.
      * @see {@link iterateParents} - to get all parents of a node
      */
-    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => RNode<OtherInfo & ParentInformation> | undefined;
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: AstIdMap<OtherInfo & ParentInformation>) => RNode<OtherInfo & ParentInformation> | undefined;
     /**
      * Returns an iterable of all parents of a node, starting with the direct parent and ending with the root node.
      */
-    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => Generator<RNode<OtherInfo & ParentInformation>>;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: AstIdMap<OtherInfo & ParentInformation>) => Generator<RNode<OtherInfo & ParentInformation>>;
     /**
      * In contrast to the nesting stored in the {@link RNode} structure,
      * this function calculates the depth of a node by counting the number of parents until the root node is reached.
      */
-    readonly depth: (this: void, node: RNode<ParentInformation>, idMap: Map<NodeId, RNode<ParentInformation>>) => number;
+    readonly depth: (this: void, node: RNode<ParentInformation>, idMap: AstIdMap<ParentInformation>) => number;
     /**
      * Collects all node ids within a tree given by a respective root node, but stops collecting at nodes where the given `stop` function returns `true`.
      * <p>

package/r-bridge/lang-4.x/ast/model/nodes/r-access.d.ts

@@ -49,9 +49,9 @@ export declare const RAccess: {
     readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
     readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
     readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
-    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
-    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
-    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<import("../processing/decorate").ParentInformation>) => number;
     readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
     readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
         lexeme: string;

package/r-bridge/lang-4.x/ast/model/nodes/r-argument.d.ts

@@ -68,9 +68,9 @@ export declare const RArgument: {
     readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
     readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>) => Set<NodeId>;
     readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
-    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => RNode<OtherInfo & ParentInformation> | undefined;
-    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => Generator<RNode<OtherInfo & ParentInformation>>;
-    readonly depth: (this: void, node: RNode<ParentInformation>, idMap: Map<NodeId, RNode<ParentInformation>>) => number;
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: import("../processing/decorate").AstIdMap<OtherInfo & ParentInformation>) => RNode<OtherInfo & ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: import("../processing/decorate").AstIdMap<OtherInfo & ParentInformation>) => Generator<RNode<OtherInfo & ParentInformation>>;
+    readonly depth: (this: void, node: RNode<ParentInformation>, idMap: import("../processing/decorate").AstIdMap<ParentInformation>) => number;
     readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>, stop: (node: RNode<OtherInfo & ParentInformation>) => boolean) => Set<NodeId>;
     readonly lexeme: <R extends RNode<ParentInformation>>(this: void, node: R | undefined) => R extends {
         lexeme: string;

package/r-bridge/lang-4.x/ast/model/nodes/r-binary-op.d.ts

@@ -30,9 +30,9 @@ export declare const RBinaryOp: {
     readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
     readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
     readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
-    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
-    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
-    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<import("../processing/decorate").ParentInformation>) => number;
     readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
     readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
         lexeme: string;

package/r-bridge/lang-4.x/ast/model/nodes/r-break.d.ts

@@ -22,9 +22,9 @@ export declare const RBreak: {
     readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
     readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
     readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
-    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
-    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
-    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: import("../processing/decorate").AstIdMap<OtherInfo & import("../processing/decorate").ParentInformation>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: import("../processing/decorate").AstIdMap<import("../processing/decorate").ParentInformation>) => number;
     readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
     readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
         lexeme: string;