@eagleoutice/flowr 2.6.1 → 2.6.2

package/dataflow/graph/vertex.d.ts

@@ -43,6 +43,9 @@ export interface NamedArgumentId {
     readonly index: number | undefined;
     readonly lexeme: string;
 }
+/**
+ * Type guard to check whether {@link identifier} is a {@link NamedArgumentId}.
+ */
 export declare function isNamedArgumentId(identifier: IndexIdentifier): identifier is NamedArgumentId;
 export type IndexIdentifier = UnnamedArgumentId | NamedArgumentId;
 /**
@@ -64,7 +67,6 @@ export interface ContainerLeafIndex {
  * A single index of a container, which is a container itself.
  *
  * This can be, e.g., a list, vector, or data frame.
- *
  * @see {@link ContainerLeafIndex} - for a single index of a container which is not a container itself
  * @see {@link isParentContainerIndex} - to check if an index is a parent container index
  */
@@ -74,6 +76,9 @@ export interface ContainerParentIndex extends ContainerLeafIndex {
      */
     readonly subIndices: ContainerIndices[];
 }
+/**
+ * Type guard to check whether {@link index} is a {@link ContainerParentIndex}.
+ */
 export declare function isParentContainerIndex(index: ContainerIndex): index is ContainerParentIndex;
 /**
  * A single index of a container.
@@ -81,13 +86,15 @@ export declare function isParentContainerIndex(index: ContainerIndex): index is
 export type ContainerIndex = ContainerLeafIndex | ContainerParentIndex;
 /**
  * Checks whether {@link index} is accessed by {@link accessLexeme}.
- *
  * @param index - The {@link ContainerIndex}, which is accessed
  * @param accessLexeme - The access lexeme
  * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
  * @returns true, when {@link accessLexeme} accesses the {@link index}, false otherwise
  */
 export declare function isAccessed(index: ContainerIndex, accessLexeme: string, isIndexBasedAccess: boolean): boolean;
+/**
+ * Checks whether two {@link ContainerIndex|container indices} are the same.
+ */
 export declare function isSameIndex(a: ContainerIndex, b: ContainerIndex): boolean;
 /**
  * List of indices of a single statement like `list(a=3, b=2)`
@@ -108,7 +115,6 @@ export interface ContainerIndices {
 export type ContainerIndicesCollection = ContainerIndices[] | undefined;
 /**
  * Arguments required to construct a vertex in the {@link DataflowGraph|dataflow graph}.
- *
  * @see DataflowGraphVertexUse
  * @see DataflowGraphVertexVariableDefinition
  * @see DataflowGraphVertexFunctionDefinition
@@ -153,7 +159,6 @@ export interface DataflowGraphVertexAstLink {
  *
  * If you have a {@link DataflowGraph|dataflow graph} named `graph`
  * with an {@link AstIdMap} and a value vertex object with name `value` the following Code should work:
- *
  * @example
  * ```ts
  * const node = graph.idMap.get(value.id)
@@ -164,7 +169,6 @@ export interface DataflowGraphVertexAstLink {
  *
  * This works similarly for {@link IdentifierReference|identifier references}
  * for which you can use the {@link IdentifierReference#nodeId|`nodeId`}.
- *
  * @see {@link isValueVertex} - to check if a vertex is a value vertex
  */
 export interface DataflowGraphVertexValue extends DataflowGraphVertexBase {
@@ -173,7 +177,6 @@ export interface DataflowGraphVertexValue extends DataflowGraphVertexBase {
 }
 /**
  * Arguments required to construct a vertex which represents the usage of a variable in the {@link DataflowGraph|dataflow graph}.
- *
  * @see {@link isUseVertex} - to check if a vertex is a use vertex
  */
 export interface DataflowGraphVertexUse extends DataflowGraphVertexBase {
@@ -185,7 +188,6 @@ export interface DataflowGraphVertexUse extends DataflowGraphVertexBase {
  * Arguments required to construct a vertex which represents the call to a function in the {@link DataflowGraph|dataflow graph}.
  * This describes all kinds of function calls, including calls to built-ins and control-flow structures such as `if` or `for` (they are
  * treated as function calls in R).
- *
  * @see {@link isFunctionCallVertex} - to check if a vertex is a function call vertex
  */
 export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase {
@@ -210,7 +212,6 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
 export type FunctionOriginInformation = BuiltInMappingName | string;
 /**
  * Arguments required to construct a vertex which represents the definition of a variable in the {@link DataflowGraph|dataflow graph}.
- *
  * @see {@link isVariableDefinitionVertex} - to check if a vertex is a variable definition vertex
  */
 export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVertexBase {
@@ -220,7 +221,6 @@ export interface DataflowGraphVertexVariableDefinition extends DataflowGraphVert
 }
 /**
  * Arguments required to construct a vertex which represents the definition of a function in the {@link DataflowGraph|dataflow graph}.
- *
  * @see {@link isFunctionDefinitionVertex} - to check if a vertex is a function definition vertex
  */
 export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVertexBase {

package/dataflow/graph/vertex.js

@@ -20,15 +20,20 @@ var VertexType;
 })(VertexType || (exports.VertexType = VertexType = {}));
 exports.ValidVertexTypes = new Set(Object.values(VertexType));
 exports.ValidVertexTypeReverse = Object.fromEntries(Object.entries(VertexType).map(([k, v]) => [v, k]));
+/**
+ * Type guard to check whether {@link identifier} is a {@link NamedArgumentId}.
+ */
 function isNamedArgumentId(identifier) {
     return 'lexeme' in identifier;
 }
+/**
+ * Type guard to check whether {@link index} is a {@link ContainerParentIndex}.
+ */
 function isParentContainerIndex(index) {
     return 'subIndices' in index;
 }
 /**
  * Checks whether {@link index} is accessed by {@link accessLexeme}.
- *
  * @param index - The {@link ContainerIndex}, which is accessed
  * @param accessLexeme - The access lexeme
  * @param isIndexBasedAccess - Whether the index of the {@link ContainerIndex} is accessed i.e. the position in the container and not e.g. the name of the index
@@ -43,6 +48,9 @@ function isAccessed(index, accessLexeme, isIndexBasedAccess) {
     }
     return false;
 }
+/**
+ * Checks whether two {@link ContainerIndex|container indices} are the same.
+ */
 function isSameIndex(a, b) {
     if (isNamedArgumentId(a.identifier) && isNamedArgumentId(b.identifier)) {
         return a.identifier.lexeme === b.identifier.lexeme;

package/dataflow/info.d.ts

@@ -8,7 +8,6 @@ import type { GenericDifferenceInformation, WriteableDifferenceReport } from '..
  * A control dependency links a vertex to the control flow element which
  * may have an influence on its execution.
  * Within `if(p) a else b`, `a` and `b` have a control dependency on the `if` (which in turn decides based on `p`).
- *
  * @see {@link happensInEveryBranch} - to check whether a list of control dependencies is exhaustive
  */
 export interface ControlDependency {
@@ -16,10 +15,11 @@ export interface ControlDependency {
     readonly id: NodeId;
     /** when does this control dependency trigger (if the condition is true or false)? */
     readonly when?: boolean;
+    /** whether this control dependency was created due to iteration (e.g., a loop) */
+    readonly byIteration?: boolean;
 }
 /**
  * Classifies the type of exit point encountered.
- *
  * @see {@link ExitPoint}
  */
 export declare const enum ExitPointType {
@@ -35,7 +35,6 @@ export declare const enum ExitPointType {
 /**
  * An exit point describes the position which ends the current control flow structure.
  * This may be as innocent as the last expression or explicit with a `return`/`break`/`next`.
- *
  * @see {@link ExitPointType} - for the different types of exit points
  * @see {@link addNonDefaultExitPoints} - to easily modify lists of exit points
  * @see {@link alwaysExits} - to check whether a list of control dependencies always triggers an exit
@@ -49,7 +48,6 @@ export interface ExitPoint {
     /**
      * Control dependencies which influence if the exit point triggers
      * (e.g., if the `return` is contained within an `if` statement).
-     *
      * @see {@link happensInEveryBranch} - to check whether control dependencies are exhaustive
      */
     readonly controlDependencies: ControlDependency[] | undefined;
@@ -73,7 +71,6 @@ export interface DataflowCfgInformation {
  * to produce a new state of the dataflow information.
  *
  * You may initialize a new dataflow information with {@link initializeCleanDataflowInformation}.
- *
  * @see {@link DataflowCfgInformation} - the control flow aspects
  */
 export interface DataflowInformation extends DataflowCfgInformation {
@@ -82,19 +79,16 @@ export interface DataflowInformation extends DataflowCfgInformation {
      *
      * For example, when we analyze the `x` vertex in `x <- 3`, we will first create an unknown reference for `x`
      * as we have not yet seen the assignment!
-     *
      * @see {@link IdentifierReference} - a reference on a variable, parameter, function call, ...
      */
     unknownReferences: readonly IdentifierReference[];
     /**
      * References which are read within the current subtree.
-     *
      * @see {@link IdentifierReference} - a reference on a variable, parameter, function call, ...
-     * */
+     */
     in: readonly IdentifierReference[];
     /**
      * References which are written to within the current subtree
-     *
      * @see {@link IdentifierReference} - a reference on a variable, parameter, function call, ...
      */
     out: readonly IdentifierReference[];
@@ -106,7 +100,6 @@ export interface DataflowInformation extends DataflowCfgInformation {
 /**
  * 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}
  */
 export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'builtInEnvironment' | 'completeAst'>): DataflowInformation;
@@ -124,5 +117,11 @@ export declare function alwaysExits(data: DataflowInformation): boolean;
  * Filters out exit points which end their cascade within a loop.
  */
 export declare function filterOutLoopExitPoints(exitPoints: readonly ExitPoint[]): readonly ExitPoint[];
+/**
+ * Calculates the difference between two control dependencies.
+ */
 export declare function diffControlDependency<Report extends WriteableDifferenceReport>(a: ControlDependency | undefined, b: ControlDependency | undefined, info: GenericDifferenceInformation<Report>): void;
+/**
+ * Calculates the difference between two lists of control dependencies.
+ */
 export declare function diffControlDependencies<Report extends WriteableDifferenceReport>(a: ControlDependency[] | undefined, b: ControlDependency[] | undefined, info: GenericDifferenceInformation<Report>): void;

package/dataflow/info.js

@@ -17,7 +17,6 @@ function addNonDefaultExitPoints(existing, add) {
 /**
  * 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}
  */
 function initializeCleanDataflowInformation(entryPoint, data) {
@@ -69,6 +68,9 @@ function alwaysExits(data) {
 function filterOutLoopExitPoints(exitPoints) {
     return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
 }
+/**
+ * Calculates the difference between two control dependencies.
+ */
 function diffControlDependency(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -83,6 +85,9 @@ function diffControlDependency(a, b, info) {
         info.report.addComment(`${info.position}Different control dependency when. ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);
     }
 }
+/**
+ * Calculates the difference between two lists of control dependencies.
+ */
 function diffControlDependencies(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {

package/dataflow/internal/linker.d.ts

@@ -1,22 +1,33 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { IdentifierReference } from '../environments/identifier';
-import type { DataflowGraph, FunctionArgument } from '../graph/graph';
+import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type IdentifierReference } from '../environments/identifier';
+import { type DataflowGraph, type FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexInfo } from '../graph/vertex';
-import type { BuiltIn } from '../environments/built-in';
+import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexFunctionDefinition, type DataflowGraphVertexInfo } from '../graph/vertex';
+import { type BuiltIn } from '../environments/built-in';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ExitPoint } from '../info';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
+/**
+ * Find all reads within the graph that do not reference a local definition in the graph.
+ */
 export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly IdentifierReference[]): IdentifierReference[];
+/**
+ * Produces a map from names to all identifier references sharing that name.
+ */
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
+/**
+ * Links the given arguments to the given parameters within the given graph.
+ */
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
+/**
+ * Links a function call with a single target function definition.
+ */
 export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, def: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): void;
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
- *
  * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
  * @param idMap     - The map to resolve ids to names
  * @param thisGraph - The graph to search for function calls in
@@ -29,20 +40,22 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
  * convenience function returning all known call targets, as well as the name source which defines them
  */
 export declare function getAllFunctionCallTargets(call: NodeId, graph: DataflowGraph, environment?: REnvironmentInformation): NodeId[];
+/**
+ * Finds all linked function definitions starting from the given set of read ids.
+ */
 export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): [Set<DataflowGraphVertexInfo>, Set<BuiltIn>];
 /**
  * This method links a set of read variables to definitions in an environment.
- *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
  * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
- *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
 export declare function linkInputs(referencesToLinkAgainstEnvironment: readonly IdentifierReference[], environmentInformation: REnvironmentInformation, givenInputs: IdentifierReference[], graph: DataflowGraph, maybeForRemaining: boolean): IdentifierReference[];
-/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+/**
+ * all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
  * for(i in 1:10) {
@@ -52,4 +65,7 @@ export declare function linkInputs(referencesToLinkAgainstEnvironment: readonly
  * `x_2` must get a read marker to `x_1` as `x_1` is the active redefinition in the second loop iteration.
  */
 export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openIns: NameIdMap, outgoing: readonly IdentifierReference[]): void;
+/**
+ * Reapplies the loop exit points' control dependencies to the given identifier references.
+ */
 export declare function reapplyLoopExitPoints(exits: readonly ExitPoint[], references: readonly IdentifierReference[]): void;

package/dataflow/internal/linker.js

@@ -24,6 +24,9 @@ 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");
+/**
+ * Find all reads within the graph that do not reference a local definition in the graph.
+ */
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
     const ids = new Set(graph.vertices(true)
@@ -64,6 +67,9 @@ function findNonLocalReads(graph, ignore) {
     }
     return nonLocalReads;
 }
+/**
+ * Produces a map from names to all identifier references sharing that name.
+ */
 function produceNameSharedIdMap(references) {
     const nameIdShares = new defaultmap_1.DefaultMap(() => []);
     for (const reference of references) {
@@ -73,6 +79,9 @@ function produceNameSharedIdMap(references) {
     }
     return nameIdShares;
 }
+/**
+ * Links the given arguments to the given parameters within the given graph.
+ */
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
     const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined).map(p => [p.name.content, p]));
@@ -136,6 +145,9 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
     linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
+/**
+ * Links a function call with a single target function definition.
+ */
 function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
     const id = info.id;
     if (info.environment !== undefined) {
@@ -184,7 +196,6 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
- *
  * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
  * @param idMap     - The map to resolve ids to names
  * @param thisGraph - The graph to search for function calls in
@@ -226,6 +237,9 @@ function getAllFunctionCallTargets(call, graph, environment) {
     }
     return found;
 }
+/**
+ * Finds all linked function definitions starting from the given set of read ids.
+ */
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
     let potential = [...functionDefinitionReadIds];
     const visited = new Set();
@@ -247,7 +261,7 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
         const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
         if (returnEdges.length > 0) {
             // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
-            potential = potential.concat(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+            potential = potential.concat(returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
             continue;
         }
         const followBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
@@ -262,13 +276,11 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
 }
 /**
  * This method links a set of read variables to definitions in an environment.
- *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
  * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
- *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
 function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation, givenInputs, graph, maybeForRemaining) {
@@ -298,7 +310,8 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
     // data.graph.get(node.id).definedAtPosition = false
     return givenInputs;
 }
-/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+/**
+ * all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
  * for(i in 1:10) {
@@ -326,6 +339,9 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
         }
     }
 }
+/**
+ * Reapplies the loop exit points' control dependencies to the given identifier references.
+ */
 function reapplyLoopExitPoints(exits, references) {
     // just apply the cds of all exit points not already present
     const exitCds = new Set(exits.flatMap(e => e.controlDependencies).filter(assert_1.isNotUndefined));
@@ -333,11 +349,11 @@ function reapplyLoopExitPoints(exits, references) {
         for (const cd of exitCds) {
             if (ref.controlDependencies) {
                 if (!ref.controlDependencies?.find(c => c.id === cd.id && c.when === cd.when)) {
-                    ref.controlDependencies.push(cd);
+                    ref.controlDependencies.push({ ...cd, byIteration: true });
                 }
             }
             else {
-                ref.controlDependencies = [cd];
+                ref.controlDependencies = [{ ...cd, byIteration: true }];
             }
         }
     }

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

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

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

@@ -6,6 +6,9 @@ const range_1 = require("../../../../../../util/range");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
+/**
+ *
+ */
 function toUnnamedArgument(node, idMap) {
     if (node === undefined) {
         return r_function_call_1.EmptyArgument;
@@ -25,6 +28,9 @@ function toUnnamedArgument(node, idMap) {
     idMap.set(arg.info.id, node);
     return arg;
 }
+/**
+ *
+ */
 function wrapArgumentsUnnamed(nodes, idMap) {
     return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === type_1.RType.Argument ? n : toUnnamedArgument(n, idMap));
 }

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

@@ -1,4 +1,4 @@
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 /**
  * Retrieve the value from an argument, if it is not empty.

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

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

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

@@ -119,6 +119,9 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
     }
     return fnCall;
 }
+/**
+ *
+ */
 function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclusive = args.length - 1) {
     const newArgs = [...args];
     // if the argument is a symbol, we convert it to a string for this perspective
@@ -201,7 +204,6 @@ function referenceAccessedIndices(newArgs, data, fnCall, rootId, isIndexBasedAcc
 /**
  * Creates edges of type {@link EdgeType.Reads} to the accessed Indices and their sub-indices starting from
  * the node with {@link parentNodeId}.
- *
  * @param accessedIndicesCollection - All indices that were accessed by the access operation
  * @param fnCall                    - The {@link ProcessKnownFunctionCallResult} of the access operation
  * @param parentNodeId              - {@link NodeId} of the parent from which the edge starts

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

@@ -1,6 +1,6 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -17,4 +17,7 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     /** Should the value of the function be resolved? */
     readonly resolveValue?: boolean;
 }
+/**
+ *
+ */
 export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -14,6 +14,9 @@ const general_1 = require("../../../../../eval/values/general");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+/**
+ *
+ */
 function processApply(name, args, rootId, data, config) {
     const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */

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

@@ -5,8 +5,8 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import { type NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { InGraphIdentifierDefinition } from '../../../../../environments/identifier';
-import type { ContainerIndicesCollection } from '../../../../../graph/vertex';
+import { type InGraphIdentifierDefinition } from '../../../../../environments/identifier';
+import { type ContainerIndicesCollection } from '../../../../../graph/vertex';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';

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

@@ -1,9 +1,12 @@
 import { type DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
-import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type DataflowInformation } from '../../../../../info';
+import { type ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ *
+ */
 export declare function processEvalCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */
     includeFunctionCall?: boolean;

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

@@ -18,6 +18,9 @@ const string_constants_1 = require("../../../../../eval/values/string/string-con
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const arrays_1 = require("../../../../../../util/collections/arrays");
+/**
+ *
+ */
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for eval currently, but got ${args.length} instead, skipping`);

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

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

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

@@ -93,6 +93,9 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
     }
     return inputEnvironment;
 }
+/**
+ *
+ */
 function processExpressionList(name, args, rootId, data) {
     const expressions = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `[expr list] with ${expressions.length} expressions`);

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

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

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

@@ -15,6 +15,9 @@ const append_1 = require("../../../../../environments/append");
 const environment_1 = require("../../../../../environments/environment");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
+/**
+ *
+ */
 function processForLoop(name, args, rootId, data) {
     if (args.length !== 3) {
         logger_1.dataflowLogger.warn(`For-Loop ${name.content} does not have three arguments, skipping`);