@eagleoutice/flowr 2.6.2 → 2.6.3

package/dataflow/eval/values/string/string-constants.js

@@ -7,7 +7,8 @@ exports.collectStrings = collectStrings;
 const general_1 = require("../general");
 const r_value_1 = require("../r-value");
 /**
- *
+ * Lift a raw string or R string value into a ValueString.
+ * @see {@link liftString} - for lifting a Lift<RStringValue>
  */
 function stringFrom(str) {
     return {
@@ -19,7 +20,8 @@ function stringFrom(str) {
     };
 }
 /**
- *
+ * Lift a Lift<RStringValue> into a ValueString.
+ * @see {@link stringFrom} - for lifting a raw string or R string value.
  */
 function liftString(str) {
     return {
@@ -28,7 +30,11 @@ function liftString(str) {
     };
 }
 /**
- *
+ * Collect strings from an array of ValueString.
+ * If any value is not a string, or is Bottom/Top, undefined is returned.
+ * @param a           - The array of Value to collect strings from.
+ * @param withQuotes  - Whether to include the quotes in the returned strings.
+ * @returns           - An array of strings, or undefined if any value is not a string.
  */
 function collectStrings(a, withQuotes = false) {
     if ((0, general_1.bottomTopGuard)(a)) {

package/dataflow/extractor.d.ts

@@ -1,10 +1,9 @@
 import type { DataflowInformation } from './info';
 import { type DataflowProcessors } from './processor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RParseRequests } from '../r-bridge/retriever';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
-import type { FlowrConfigOptions } from '../config';
+import type { FlowrAnalyzerContext } from '../project/context/flowr-analyzer-context';
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -16,6 +15,6 @@ export declare const processors: DataflowProcessors<ParentInformation>;
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>, config: FlowrConfigOptions): DataflowInformation & {
+export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, completeAst: NormalizedAst<OtherInfo & ParentInformation>, ctx: FlowrAnalyzerContext): DataflowInformation & {
     cfgQuick: ControlFlowInformation | undefined;
 };

package/dataflow/extractor.js

@@ -21,6 +21,7 @@ const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
 const built_in_config_1 = require("./environments/built-in-config");
+const flowr_file_1 = require("../project/context/flowr-file");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -60,13 +61,24 @@ exports.processors = {
 };
 function resolveLinkToSideEffects(ast, graph) {
     let cf = undefined;
+    let knownCalls;
+    const handled = new Set();
     for (const s of graph.unknownSideEffects) {
         if (typeof s !== 'object') {
             continue;
         }
-        cf ??= (0, extract_cfg_1.extractCfgQuick)(ast);
+        if (cf === undefined) {
+            cf = (0, extract_cfg_1.extractCfgQuick)(ast);
+            if (graph.unknownSideEffects.size > 20) {
+                knownCalls = (0, extract_cfg_1.getCallsInCfg)(cf, graph);
+            }
+        }
+        else if (handled.has(s.id)) {
+            continue;
+        }
+        handled.add(s.id);
         /* this has to change whenever we add a new link to relations because we currently offer no abstraction for the type */
-        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cf?.graph, graph, s.linkTo);
+        const potentials = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(s.id, cf.graph, graph, s.linkTo, knownCalls);
         for (const pot of potentials) {
             graph.addEdge(s.id, pot, edge_1.EdgeType.Reads);
         }
@@ -82,36 +94,27 @@ function resolveLinkToSideEffects(ast, graph) {
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-function produceDataFlowGraph(parser, request, completeAst, config) {
-    let firstRequest;
-    const multifile = Array.isArray(request);
-    if (multifile) {
-        firstRequest = request[0];
-    }
-    else {
-        firstRequest = request;
-    }
-    const builtInsConfig = config.semantics.environment.overwriteBuiltIns;
+function produceDataFlowGraph(parser, completeAst, ctx) {
+    const builtInsConfig = ctx.config.semantics.environment.overwriteBuiltIns;
     const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
     const env = (0, environment_1.initializeCleanEnvironments)(builtIns.builtInMemory);
+    // we freeze the files here to avoid endless modifications during processing
+    const files = completeAst.ast.files.slice();
+    ctx.files.addConsideredFile(files[0].filePath ? files[0].filePath : flowr_file_1.FlowrFile.INLINE_PATH);
     const dfData = {
         parser,
         completeAst,
         environment: env,
         builtInEnvironment: env.current.parent,
         processors: exports.processors,
-        currentRequest: firstRequest,
         controlDependencies: undefined,
-        referenceChain: [firstRequest],
-        flowrConfig: config
+        referenceChain: [files[0].filePath],
+        ctx
     };
-    let df = (0, processor_1.processDataflowFor)(completeAst.ast, dfData);
-    df.graph.sourced.unshift(firstRequest.request === 'file' ? firstRequest.content : '<inline>');
-    if (multifile) {
-        for (let i = 1; i < request.length; i++) {
-            /* source requests register automatically */
-            df = (0, built_in_source_1.standaloneSourceFile)(request[i], dfData, `root-${i}`, df);
-        }
+    let df = (0, processor_1.processDataflowFor)(files[0].root, dfData);
+    for (let i = 1; i < files.length; i++) {
+        /* source requests register automatically */
+        df = (0, built_in_source_1.standaloneSourceFile)(i, files[i], dfData, df);
     }
     // finally, resolve linkages
     (0, built_in_function_definition_1.updateNestedFunctionCalls)(df.graph, df.environment);

package/dataflow/graph/graph.d.ts

@@ -71,15 +71,14 @@ export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
     readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
-    readonly sourced?: (string | '<inline>')[];
 }
 /**
  * An unknown side effect describes something that we cannot handle correctly (in all cases).
- * For example, `eval` will be marked as an unknown side effect as we have no idea of how it will affect the program.
+ * For example, `load` will be marked as an unknown side effect as we have no idea of how it will affect the program.
  * Linked side effects are used whenever we know that a call may be affected by another one in a way that we cannot
  * grasp from the dataflow perspective (e.g., an indirect dependency based on the currently active graphic device).
  */
-export type UnknownSidEffect = NodeId | {
+export type UnknownSideEffect = NodeId | {
     id: NodeId;
     linkTo: LinkTo<RegExp>;
 };
@@ -101,8 +100,6 @@ export type UnknownSidEffect = NodeId | {
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
     private _idMap;
-    /** all file paths included in this dfg */
-    private _sourced;
     private readonly _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
@@ -138,13 +135,10 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     getLinked(nodeId: NodeId): NodeId[] | undefined;
     /** Retrieves the id-map to the normalized AST attached to the dataflow graph */
     get idMap(): AstIdMap | undefined;
-    get sourced(): (string | '<inline>')[];
-    /** Mark this file as being part of the dfg */
-    addFile(source: string | '<inline>'): void;
     /**
      * Retrieves the set of vertices which have side effects that we do not know anything about.
      */
-    get unknownSideEffects(): Set<UnknownSidEffect>;
+    get unknownSideEffects(): Set<UnknownSideEffect>;
     /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
     setIdMap(idMap: AstIdMap): void;
     /**

package/dataflow/graph/graph.js

@@ -53,8 +53,6 @@ function getReferenceOfArgument(arg) {
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
-    /** all file paths included in this dfg */
-    _sourced = [];
     /*
      * Set of vertices which have sideEffects that we do not know anything about.
      * As a (temporary) solution until we have FD edges, a side effect may also store known target links
@@ -127,13 +125,6 @@ class DataflowGraph {
     get idMap() {
         return this._idMap;
     }
-    get sourced() {
-        return this._sourced;
-    }
-    /** Mark this file as being part of the dfg */
-    addFile(source) {
-        this._sourced.push(source);
-    }
     /**
      * Retrieves the set of vertices which have side effects that we do not know anything about.
      */
@@ -248,7 +239,6 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
-        this._sourced = this._sourced.concat(otherGraph.sourced);
         for (const unknown of otherGraph.unknownSideEffects) {
             this._unknownSideEffects.add(unknown);
         }
@@ -348,9 +338,6 @@ class DataflowGraph {
             }
         }
         graph.edgeInformation = new Map(data.edgeInformation.map(([id, edges]) => [id, new Map(edges)]));
-        if (data.sourced) {
-            graph._sourced = data.sourced;
-        }
         return graph;
     }
 }

package/dataflow/graph/unknown-replacement.d.ts

@@ -8,10 +8,12 @@ export type ReplacementOperatorHandlerArgs = {
 };
 export type ReplacementOperatorHandler = (args: ReplacementOperatorHandlerArgs) => void;
 /**
- *
+ * Register a new (global) handler for replacement operators.
+ * @see {@link handleReplacementOperator}
  */
 export declare function onReplacementOperator(handler: ReplacementOperatorHandler): void;
 /**
- *
+ * Handle a replacement operator by calling all registered handlers.
+ * @see {@link onReplacementOperator}
  */
 export declare function handleReplacementOperator(args: ReplacementOperatorHandlerArgs): void;

package/dataflow/graph/unknown-replacement.js

@@ -4,13 +4,15 @@ exports.onReplacementOperator = onReplacementOperator;
 exports.handleReplacementOperator = handleReplacementOperator;
 const handlers = [];
 /**
- *
+ * Register a new (global) handler for replacement operators.
+ * @see {@link handleReplacementOperator}
  */
 function onReplacementOperator(handler) {
     handlers.push(handler);
 }
 /**
- *
+ * Handle a replacement operator by calling all registered handlers.
+ * @see {@link onReplacementOperator}
  */
 function handleReplacementOperator(args) {
     handlers.forEach(handler => handler(args));

package/dataflow/info.d.ts

@@ -106,8 +106,15 @@ export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranchSet} - for the set-based version
  */
 export declare function happensInEveryBranch(controlDependencies: readonly ControlDependency[] | undefined): boolean;
+/**
+ * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
+ * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranch} - for the array-based version
+ */
+export declare function happensInEveryBranchSet(controlDependencies: ReadonlySet<ControlDependency> | undefined): boolean;
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points

package/dataflow/info.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
 exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
 exports.happensInEveryBranch = happensInEveryBranch;
+exports.happensInEveryBranchSet = happensInEveryBranchSet;
 exports.alwaysExits = alwaysExits;
 exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
 exports.diffControlDependency = diffControlDependency;
@@ -33,6 +34,7 @@ function initializeCleanDataflowInformation(entryPoint, data) {
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranchSet} - for the set-based version
  */
 function happensInEveryBranch(controlDependencies) {
     if (controlDependencies === undefined) {
@@ -43,6 +45,9 @@ function happensInEveryBranch(controlDependencies) {
         /* this happens only when we have no idea and require more analysis */
         return false;
     }
+    return coversSet(controlDependencies);
+}
+function coversSet(controlDependencies) {
     const trues = [];
     const falseSet = new Set();
     for (const { id, when } of controlDependencies) {
@@ -55,6 +60,22 @@ function happensInEveryBranch(controlDependencies) {
     }
     return trues.every(id => falseSet.has(id));
 }
+/**
+ * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
+ * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranch} - for the array-based version
+ */
+function happensInEveryBranchSet(controlDependencies) {
+    if (controlDependencies === undefined) {
+        /* the cds are unconstrained */
+        return true;
+    }
+    else if (controlDependencies.size === 0) {
+        /* this happens only when we have no idea and require more analysis */
+        return false;
+    }
+    return coversSet(controlDependencies);
+}
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points

package/dataflow/internal/linker.js

@@ -241,7 +241,7 @@ function getAllFunctionCallTargets(call, graph, environment) {
  * Finds all linked function definitions starting from the given set of read ids.
  */
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
-    let potential = [...functionDefinitionReadIds];
+    let potential = functionDefinitionReadIds.values().toArray();
     const visited = new Set();
     const result = new Set();
     const builtIns = new Set();
@@ -257,8 +257,9 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
             continue;
         }
         visited.add(currentId);
-        const outgoingEdges = [...currentInfo[1]];
-        const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
+        const outgoingEdges = currentInfo[1].entries().toArray();
+        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)));
@@ -270,7 +271,9 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
             result.add(currentInfo[0]);
         }
         // trace all joined reads
-        potential = potential.concat(followEdges.map(([target]) => target).filter(id => !visited.has(id)));
+        potential = potential.concat(followEdges
+            .map(([target]) => target)
+            .filter(id => !visited.has(id)));
     }
     return [result, builtIns];
 }

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

@@ -3,10 +3,10 @@ import type { AstIdMap, ParentInformation } from '../../../../../../r-bridge/lan
 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';
 /**
- *
+ * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
 export declare function toUnnamedArgument<OtherInfo>(node: RNode<OtherInfo & ParentInformation> | undefined, idMap: AstIdMap<OtherInfo>): RUnnamedArgument<OtherInfo & ParentInformation> | typeof EmptyArgument;
 /**
- *
+ * Wraps the given nodes as unnamed arguments where necessary.
  */
 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

@@ -7,7 +7,7 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
 /**
- *
+ * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
 function toUnnamedArgument(node, idMap) {
     if (node === undefined) {
@@ -16,7 +16,6 @@ function toUnnamedArgument(node, idMap) {
     const arg = {
         type: type_1.RType.Argument,
         lexeme: node.lexeme ?? '',
-        // is this correct?
         location: node.location ?? voidRange,
         info: {
             ...node.info,
@@ -29,7 +28,7 @@ function toUnnamedArgument(node, idMap) {
     return arg;
 }
 /**
- *
+ * Wraps the given nodes as unnamed arguments where necessary.
  */
 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/built-in/built-in-access.d.ts

@@ -20,6 +20,6 @@ export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & Paren
     treatIndicesAsString: boolean;
 } & ForceArguments): DataflowInformation;
 /**
- *
+ * Converts symbol arguments to string arguments within the specified range.
  */
 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

@@ -114,16 +114,16 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
     if (head.value && outInfo.definitionRootNodes.length > 0) {
         (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data);
     }
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(args, data, fnCall, rootId, true);
     }
     return fnCall;
 }
 /**
- *
+ * Converts symbol arguments to string arguments within the specified range.
  */
 function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclusive = args.length - 1) {
-    const newArgs = [...args];
+    const newArgs = args.slice();
     // if the argument is a symbol, we convert it to a string for this perspective
     for (let i = firstIndexInclusive; i <= lastIndexInclusive; i++) {
         const arg = newArgs[i];
@@ -159,7 +159,7 @@ function processStringBasedAccess(args, data, name, rootId, config) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs,
         origin: 'builtin:access'
     });
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(newArgs, data, fnCall, rootId, false);
     }
     return fnCall;

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

@@ -60,7 +60,7 @@ function processApply(name, args, rootId, data, config) {
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
         if (resolveValue) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables }));
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables }));
             if (resolved?.elements.length === 1 && resolved.elements[0].type === 'string') {
                 functionName = (0, r_value_1.isValue)(resolved.elements[0].value) ? resolved.elements[0].value.str : undefined;
             }

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

@@ -112,7 +112,7 @@ args, rootId, data, config) {
         }
         else {
             // try to resolve the variable first
-            const n = (0, alias_tracking_1.resolveIdToValue)(target.info.id, { environment: data.environment, resolve: data.flowrConfig.solver.variables, idMap: data.completeAst.idMap, full: true });
+            const n = (0, alias_tracking_1.resolveIdToValue)(target.info.id, { environment: data.environment, resolve: data.ctx.config.solver.variables, idMap: data.completeAst.idMap, full: true });
             if (n.type === 'set' && n.elements.length === 1 && n.elements[0].type === 'string') {
                 const val = n.elements[0].value;
                 if ((0, r_value_1.isValue)(val)) {
@@ -259,7 +259,7 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param assignmentConfig   - configuration for the assignment processing
  */
 function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, data, assignmentConfig) {
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
             // support for tracking indices.
@@ -288,7 +288,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
         }
         nodeToDefine.indicesCollection ??= indicesCollection;
     }
-    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.flowrConfig);
+    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.ctx.config);
     information.graph.setDefinitionOfVertex(nodeToDefine);
     if (!assignmentConfig?.quoteSource) {
         for (const sourceId of sourceIds) {
@@ -343,7 +343,7 @@ function processAssignmentToSymbol(config) {
         unknownReferences: [],
         entryPoint: rootId,
         in: readTargets,
-        out: [...writeNodes, ...readFromSourceWritten]
+        out: writeNodes.concat(readFromSourceWritten),
     };
 }
 //# sourceMappingURL=built-in-assignment.js.map

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

@@ -33,12 +33,12 @@ function processEvalCall(name, args, rootId, data, config) {
     if (config.includeFunctionCall) {
         information.graph.addEdge(rootId, args[0].value.info.id, edge_1.EdgeType.Returns);
     }
-    if (!data.flowrConfig.solver.evalStrings) {
+    if (!data.ctx.config.solver.evalStrings) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
-    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.flowrConfig);
+    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.ctx.config);
     if (code) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
@@ -60,10 +60,10 @@ function processEvalCall(name, args, rootId, data, config) {
             graph: result.reduce((acc, r) => acc.mergeWith(r.graph), information.graph),
             environment: result.reduce((acc, r) => (0, append_1.appendEnvironment)(acc, r.environment), information.environment),
             entryPoint: rootId,
-            out: [...information.out, ...result.flatMap(r => r.out)],
-            in: [...information.in, ...result.flatMap(r => r.in)],
-            unknownReferences: [...information.unknownReferences, ...result.flatMap(r => r.unknownReferences)],
-            exitPoints: [...information.exitPoints, ...result.flatMap(r => r.exitPoints)],
+            out: information.out.concat(result.flatMap(r => r.out)),
+            in: information.in.concat(result.flatMap(r => r.in)),
+            unknownReferences: information.unknownReferences.concat(result.flatMap(r => r.unknownReferences)),
+            exitPoints: information.exitPoints.concat(result.flatMap(r => r.exitPoints)),
         };
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);

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

@@ -153,7 +153,7 @@ function processExpressionList(name, args, rootId, data) {
             controlDependencies: data.controlDependencies
         });
     }
-    const ingoing = [...remainingRead.values()].flat();
+    const ingoing = remainingRead.values().toArray().flat();
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {

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

@@ -37,7 +37,7 @@ function processForLoop(name, args, rootId, data) {
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = variable.unknownReferences.concat(variable.in);
     for (const write of writtenVariable) {
-        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.flowrConfig);
+        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.ctx.config);
     }
     data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);

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

@@ -42,7 +42,7 @@ function processFunctionDefinition(name, args, rootId, data) {
         (0, assert_1.guard)(param !== r_function_call_1.EmptyArgument, () => `Empty argument in function definition ${name.content}, ${JSON.stringify(args)}`);
         const processed = (0, processor_1.processDataflowFor)(param, data);
         subgraph.mergeWith(processed.graph);
-        const read = [...processed.in, ...processed.unknownReferences];
+        const read = processed.in.concat(processed.unknownReferences);
         (0, linker_1.linkInputs)(read, data.environment, readInParameters, subgraph, false);
         data = { ...data, environment: (0, overwrite_1.overwriteEnvironment)(data.environment, processed.environment) };
     }

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

@@ -5,6 +5,6 @@ import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 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';
 /**
- *
+ * Processes a built-in 'get' function call.
  */
 export declare function processGet<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-get.js

@@ -9,7 +9,7 @@ const retriever_1 = require("../../../../../../r-bridge/retriever");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../../../graph/edge");
 /**
- *
+ * Processes a built-in 'get' function call.
  */
 function processGet(name, args, rootId, data) {
     if (args.length !== 1) {

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.js

@@ -37,7 +37,7 @@ function processIfThenElse(name, args, rootId, data) {
     let then;
     let makeThenMaybe = false;
     // we should defer this to the abstract interpretation
-    const values = (0, alias_tracking_1.resolveIdToValue)(condArg?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables });
+    const values = (0, alias_tracking_1.resolveIdToValue)(condArg?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables });
     const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
     const conditionIsAlwaysTrue = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
     if (!conditionIsAlwaysFalse) {

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

@@ -16,7 +16,7 @@ const containers_1 = require("../../../../../../util/containers");
  */
 function processList(name, args, rootId, data) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:list' });
-    if (!data.flowrConfig.solver.pointerTracking) {
+    if (!data.ctx.config.solver.pointerTracking) {
         return fnCall.information;
     }
     const listArgs = [];
@@ -67,7 +67,7 @@ function processList(name, args, rootId, data) {
         }
         listArgs.push(newIndex);
     }
-    if ((0, config_1.isOverPointerAnalysisThreshold)(data.flowrConfig, listArgs.length)) {
+    if ((0, config_1.isOverPointerAnalysisThreshold)(data.ctx.config, listArgs.length)) {
         return fnCall.information;
     }
     const indices = {

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

@@ -38,19 +38,19 @@ function processPipe(name, args, rootId, data) {
         information.graph.addEdge(functionCallNode.id, argId, edge_1.EdgeType.Argument | edge_1.EdgeType.Reads);
     }
     const firstArgument = processedArguments[0];
-    const uniqueIn = [...information.in];
+    const uniqueIn = information.in.slice();
     for (const ing of (firstArgument?.in ?? [])) {
         if (!uniqueIn.find(e => e.nodeId === ing.nodeId)) {
             uniqueIn.push(ing);
         }
     }
-    const uniqueOut = [...information.out];
+    const uniqueOut = information.out.slice();
     for (const outg of (firstArgument?.out ?? [])) {
         if (!uniqueOut.find(e => e.nodeId === outg.nodeId)) {
             uniqueOut.push(outg);
         }
     }
-    const uniqueUnknownReferences = [...information.unknownReferences];
+    const uniqueUnknownReferences = information.unknownReferences.slice();
     for (const unknown of (firstArgument?.unknownReferences ?? [])) {
         if (!uniqueUnknownReferences.find(e => e.nodeId === unknown.nodeId)) {
             uniqueUnknownReferences.push(unknown);

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

@@ -5,6 +5,11 @@ import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 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';
 /**
- *
+ * Process a built-in repeat loop function call like `repeat { ... }`.
+ * @param name     - The name of the function being called.
+ * @param args     - The arguments passed to the function.
+ * @param rootId   - The root node ID for the current processing context.
+ * @param data     - Additional dataflow processor information.
+ * @returns        - The resulting dataflow information after processing the repeat loop.
  */
 export declare function processRepeatLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;