@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSourceProvider = getSourceProvider;
-exports.setSourceProvider = setSourceProvider;
 exports.inferWdFromScript = inferWdFromScript;
+exports.platformBasename = platformBasename;
+exports.platformDirname = platformDirname;
 exports.findSource = findSource;
 exports.processSourceCall = processSourceCall;
 exports.sourceRequest = sourceRequest;
@@ -21,7 +21,6 @@ const logger_1 = require("../../../../../logger");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const log_1 = require("../../../../../../util/log");
-const fs_1 = __importDefault(require("fs"));
 const parser_1 = require("../../../../../../r-bridge/lang-4.x/ast/parser/json/parser");
 const shell_executor_1 = require("../../../../../../r-bridge/shell-executor");
 const assert_1 = require("../../../../../../util/assert");
@@ -30,31 +29,36 @@ const general_1 = require("../../../../../eval/values/general");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
-let sourceProvider = (0, retriever_1.requestProviderFromFile)();
-function getSourceProvider() {
-    return sourceProvider;
-}
-function setSourceProvider(provider) {
-    sourceProvider = provider;
-}
+/**
+ * Infers working directories based on the given option and reference chain
+ */
 function inferWdFromScript(option, referenceChain) {
     switch (option) {
         case config_1.InferWorkingDirectory.MainScript:
-            return referenceChain[0]?.request === 'file' ? [platformDirname(referenceChain[0].content)] : [];
-        case config_1.InferWorkingDirectory.ActiveScript:
-            return referenceChain[referenceChain.length - 1] ? [platformDirname(referenceChain[referenceChain.length - 1].content)] : [];
+            return referenceChain[0] ? [platformDirname(referenceChain[0])] : [];
+        case config_1.InferWorkingDirectory.ActiveScript: {
+            const secondToLast = referenceChain[referenceChain.length - 1];
+            return secondToLast ? [platformDirname(secondToLast)] : [];
+        }
         case config_1.InferWorkingDirectory.AnyScript:
-            return referenceChain.filter(e => e.request === 'file').map(e => platformDirname(e.content));
+            return referenceChain.filter(assert_1.isNotUndefined).map(e => platformDirname(e));
         case config_1.InferWorkingDirectory.No:
         default:
             return [];
     }
 }
 const AnyPathSeparator = /[/\\]/g;
+/**
+ * Return the basename of a path in a platform-agnostic way
+ * @see {@link platformDirname} - for the dirname counterpart
+ */
 function platformBasename(p) {
     const normalized = p.replaceAll(path_1.default.win32.sep, path_1.default.posix.sep);
     return path_1.default.posix.basename(normalized);
 }
+/**
+ * Return the dirname of a path in a platform-agnostic way
+ */
 function platformDirname(p) {
     const normalized = p.replaceAll(path_1.default.win32.sep, path_1.default.posix.sep);
     return path_1.default.posix.dirname(normalized);
@@ -78,10 +82,7 @@ function applyReplacements(path, replacements) {
  */
 function findSource(resolveSource, seed, data) {
     const capitalization = resolveSource?.ignoreCapitalization ?? false;
-    const explorePaths = [
-        ...(resolveSource?.searchPath ?? []),
-        ...(inferWdFromScript(resolveSource?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
-    ];
+    const explorePaths = (resolveSource?.searchPath ?? []).concat(inferWdFromScript(resolveSource?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain));
     let tryPaths = [seed];
     switch (resolveSource?.dropPaths ?? config_1.DropPathsOption.No) {
         case config_1.DropPathsOption.Once: {
@@ -113,7 +114,8 @@ function findSource(resolveSource, seed, data) {
     for (const explore of [undefined, ...explorePaths]) {
         for (const tryPath of tryPaths) {
             const effectivePath = explore ? path_1.default.join(explore, tryPath) : tryPath;
-            const get = sourceProvider.exists(effectivePath, capitalization) ?? sourceProvider.exists(returnPlatformPath(effectivePath), capitalization);
+            const context = data.ctx.files;
+            const get = context.exists(effectivePath, capitalization) ?? context.exists(returnPlatformPath(effectivePath), capitalization);
             if (get && !found.includes(effectivePath)) {
                 found.push(returnPlatformPath(effectivePath));
             }
@@ -124,6 +126,9 @@ function findSource(resolveSource, seed, data) {
     }
     return found;
 }
+/**
+ * Processes a named function call (i.e., not an anonymous function)
+ */
 function processSourceCall(name, args, rootId, data, config) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for source currently, but got ${args.length} instead, skipping`);
@@ -133,7 +138,7 @@ function processSourceCall(name, args, rootId, data, config) {
         (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:source' }).information
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const sourceFileArgument = args[0];
-    if (!config.forceFollow && data.flowrConfig.ignoreSourceCalls) {
+    if (!config.forceFollow && data.ctx.config.ignoreSourceCalls) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping source call ${JSON.stringify(sourceFileArgument)} (disabled in config file)`);
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
@@ -143,54 +148,75 @@ function processSourceCall(name, args, rootId, data, config) {
         sourceFile = [(0, retriever_1.removeRQuotes)(sourceFileArgument.lexeme)];
     }
     else if (sourceFileArgument !== r_function_call_1.EmptyArgument) {
-        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(sourceFileArgument.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)(sourceFileArgument.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables }));
         sourceFile = resolved?.elements.map(r => r.type === 'string' && (0, r_value_1.isValue)(r.value) ? r.value.str : undefined).filter(assert_1.isNotUndefined);
     }
     if (sourceFile && sourceFile.length === 1) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile[0]);
-        let filepath = path ? findSource(data.flowrConfig.solver.resolveSource, path, data) : path;
+        let filepath = path ? findSource(data.ctx.config.solver.resolveSource, path, data) : path;
         if (Array.isArray(filepath)) {
             filepath = filepath?.[0];
         }
         if (filepath !== undefined) {
-            const request = sourceProvider.createRequest(filepath);
             // check if the sourced file has already been dataflow analyzed, and if so, skip it
-            const limit = data.flowrConfig.solver.resolveSource?.repeatedSourceLimit ?? 0;
-            const findCount = data.referenceChain.filter(e => e.request === request.request && e.content === request.content).length;
+            const limit = data.ctx.config.solver.resolveSource?.repeatedSourceLimit ?? 0;
+            const findCount = data.referenceChain.filter(e => e !== undefined && filepath === e).length;
             if (findCount > limit) {
-                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+                logger_1.dataflowLogger.warn(`Found cycle (>=${limit + 1}) in dataflow analysis for ${JSON.stringify(filepath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
                 (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
                 return information;
             }
-            return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
+            return sourceRequest(rootId, { request: 'file', content: filepath }, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)((findCount > 0 ? findCount + '::' : '') + path, name.location));
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
     (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
+/**
+ * Processes a source request with the given dataflow processor information and existing dataflow information
+ * Otherwise, this can be an {@link RProjectFile} representing a standalone source file
+ */
 function sourceRequest(rootId, request, data, information, getId) {
-    if (request.request === 'file') {
-        /* check if the file exists and if not, fail */
-        if (!fs_1.default.existsSync(request.content)) {
+    // parse, normalize and dataflow the sourced file
+    let dataflow;
+    let fst;
+    let filePath;
+    if ('root' in request) {
+        fst = request;
+        filePath = request.filePath;
+    }
+    else {
+        const textRequest = data.ctx.files.resolveRequest(request);
+        if (textRequest === undefined && request.request === 'file') {
+            // if translation failed there is nothing we can do!!
             logger_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}: file does not exist`);
             (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
             return information;
         }
+        else {
+            (0, assert_1.guard)(textRequest !== undefined, `Expected text request to be defined for sourced file ${JSON.stringify(request)}`);
+        }
+        const parsed = (!data.parser.async ? data.parser : new shell_executor_1.RShellExecutor()).parse(textRequest.r);
+        const normalized = (typeof parsed !== 'string' ?
+            (0, parser_1.normalizeTreeSitter)({ files: [{ parsed, filePath: textRequest.path }] }, getId, data.ctx.config)
+            : (0, parser_1.normalize)({ files: [{ parsed, filePath: textRequest.path }] }, getId));
+        fst = normalized.ast.files[0];
+        // this can be improved, see issue #628
+        for (const [k, v] of normalized.idMap) {
+            data.completeAst.idMap.set(k, v);
+        }
+        // add to the main ast
+        if (!data.completeAst.ast.files.find(f => f.filePath === fst.filePath)) {
+            data.completeAst.ast.files.push(fst);
+        }
+        filePath = textRequest.path;
     }
-    // parse, normalize and dataflow the sourced file
-    let normalized;
-    let dataflow;
     try {
-        const file = request.request === 'file' ? request.content : undefined;
-        const parsed = (!data.parser.async ? data.parser : new shell_executor_1.RShellExecutor()).parse(request);
-        normalized = (typeof parsed !== 'string' ?
-            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, data.flowrConfig, file) : (0, parser_1.normalize)({ parsed }, getId, file));
-        dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
+        dataflow = (0, processor_1.processDataflowFor)(fst.root, {
             ...data,
-            currentRequest: request,
             environment: information.environment,
-            referenceChain: [...data.referenceChain, request]
+            referenceChain: [...data.referenceChain, fst.filePath]
         });
     }
     catch (e) {
@@ -200,44 +226,40 @@ function sourceRequest(rootId, request, data, information, getId) {
         return information;
     }
     // take the entry point as well as all the written references, and give them a control dependency to the source call to show that they are conditional
-    if (dataflow.graph.hasVertex(dataflow.entryPoint)) {
-        dataflow.graph.addControlDependency(dataflow.entryPoint, rootId, true);
-    }
-    for (const out of dataflow.out) {
-        dataflow.graph.addControlDependency(out.nodeId, rootId, true);
+    if (!String(rootId).startsWith('file-')) {
+        if (dataflow.graph.hasVertex(dataflow.entryPoint)) {
+            dataflow.graph.addControlDependency(dataflow.entryPoint, rootId, true);
+        }
+        for (const out of dataflow.out) {
+            dataflow.graph.addControlDependency(out.nodeId, rootId, true);
+        }
     }
-    dataflow.graph.addFile(request.request === 'file' ? request.content : '<inline>');
+    data.ctx.files.addConsideredFile(filePath ?? '<inline>');
     // update our graph with the sourced file's information
-    const newInformation = { ...information };
-    newInformation.environment = (0, overwrite_1.overwriteEnvironment)(information.environment, dataflow.environment);
-    newInformation.graph.mergeWith(dataflow.graph);
-    // this can be improved, see issue #628
-    for (const [k, v] of normalized.idMap) {
-        data.completeAst.idMap.set(k, v);
-    }
     return {
-        ...newInformation,
-        in: newInformation.in.concat(dataflow.in),
-        out: newInformation.out.concat(dataflow.out),
-        unknownReferences: newInformation.unknownReferences.concat(dataflow.unknownReferences),
+        ...information,
+        environment: (0, overwrite_1.overwriteEnvironment)(information.environment, dataflow.environment),
+        graph: information.graph.mergeWith(dataflow.graph),
+        in: information.in.concat(dataflow.in),
+        out: information.out.concat(dataflow.out),
+        unknownReferences: information.unknownReferences.concat(dataflow.unknownReferences),
         exitPoints: dataflow.exitPoints
     };
 }
-function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
-    const path = inputRequest.request === 'file' ? inputRequest.content : '-inline-';
-    /* this way we can still pass content */
-    const request = inputRequest.request === 'file' ? sourceProvider.createRequest(inputRequest.content) : inputRequest;
+/**
+ * Processes a standalone source file (i.e., not from a source function call)
+ */
+function standaloneSourceFile(idx, file, data, information) {
     // check if the sourced file has already been dataflow analyzed, and if so, skip it
-    if (data.referenceChain.find(e => e.request === request.request && e.content === request.content)) {
-        logger_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
-        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, uniqueSourceId);
+    if (data.referenceChain.find(e => e !== undefined && e === file.filePath)) {
+        logger_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(file.filePath)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, file.root.info.id);
         return information;
     }
-    return sourceRequest(uniqueSourceId, request, {
+    return sourceRequest('file-' + idx, file, {
         ...data,
-        currentRequest: request,
         environment: information.environment,
-        referenceChain: [...data.referenceChain, inputRequest]
-    }, information, (0, decorate_1.deterministicPrefixIdGenerator)(path + '::' + uniqueSourceId));
+        referenceChain: [...data.referenceChain, file.filePath]
+    }, information);
 }
 //# sourceMappingURL=built-in-source.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.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';
 import type { ForceArguments } from '../common';
+/**
+ * Process a special built-in binary operator, possibly lazily.
+ * For example, the logical AND `&&` and OR `||` operators only evaluate their right-hand side if necessary.
+ * Please note that this is not (directly) related to R's special binary operators like `%in%`.
+ */
 export declare function processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     lazy: boolean;
     evalRhsWhen: boolean;

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.js

@@ -4,6 +4,11 @@ exports.processSpecialBinOp = processSpecialBinOp;
 const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const edge_1 = require("../../../../../graph/edge");
+/**
+ * Process a special built-in binary operator, possibly lazily.
+ * For example, the logical AND `&&` and OR `||` operators only evaluate their right-hand side if necessary.
+ * Please note that this is not (directly) related to R's special binary operators like `%in%`.
+ */
 function processSpecialBinOp(name, args, rootId, data, config) {
     if (!config.lazy) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:special-bin-op' }).information;

package/dataflow/internal/process/functions/call/built-in/built-in-vector.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 { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';

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

@@ -16,7 +16,7 @@ const containers_1 = require("../../../../../../util/containers");
  */
 function processVector(name, args, rootId, data) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:vector' });
-    if (!data.flowrConfig.solver.pointerTracking) {
+    if (!data.ctx.config.solver.pointerTracking) {
         return fnCall.information;
     }
     let vectorArgs = [];
@@ -52,7 +52,7 @@ function processVector(name, args, rootId, data) {
             vectorArgs = vectorArgs.concat(flattenedIndices);
         }
     }
-    if ((0, config_1.isOverPointerAnalysisThreshold)(data.flowrConfig, vectorArgs.length)) {
+    if ((0, config_1.isOverPointerAnalysisThreshold)(data.ctx.config, vectorArgs.length)) {
         return fnCall.information;
     }
     const indices = {

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

@@ -1,7 +1,10 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
+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';
+/**
+ *
+ */
 export declare function processWhileLoop<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-while-loop.js

@@ -13,6 +13,9 @@ const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+/**
+ *
+ */
 function processWhileLoop(name, args, rootId, data) {
     if (args.length !== 2 || args[1] === r_function_call_1.EmptyArgument) {
         logger_1.dataflowLogger.warn(`While-Loop ${name.content} does not have 2 arguments, skipping`);
@@ -24,7 +27,7 @@ function processWhileLoop(name, args, rootId, data) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     // we should defer this to the abstract interpretation
-    const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables });
+    const values = (0, alias_tracking_1.resolveIdToValue)(unpackedArgs[0]?.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;
     //We don't care about the body if it never executes
     if (conditionIsAlwaysFalse) {

package/dataflow/internal/process/functions/call/common.d.ts

@@ -1,13 +1,13 @@
-import type { DataflowInformation } from '../../../../info';
-import type { DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowInformation } from '../../../../info';
+import { type DataflowProcessorInformation } from '../../../../processor';
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 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 { DataflowGraph, FunctionArgument } from '../../../../graph/graph';
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../../../environments/environment';
-import type { IdentifierReference } from '../../../../environments/identifier';
-import type { DataflowGraphVertexAstLink, FunctionOriginInformation } from '../../../../graph/vertex';
+import { type IdentifierReference } from '../../../../environments/identifier';
+import { type DataflowGraphVertexAstLink, type FunctionOriginInformation } from '../../../../graph/vertex';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 export interface ForceArguments {
     /** which of the arguments should be forced? this may be all, e.g., if the function itself is unknown on encounter */
@@ -29,6 +29,9 @@ export interface ProcessAllArgumentResult {
     readonly remainingReadInArgs: IdentifierReference[];
     readonly processedArguments: (DataflowInformation | undefined)[];
 }
+/**
+ * Processes all arguments for a function call, updating the given final graph and environment.
+ */
 export declare function processAllArguments<OtherInfo>({ functionName, args, data, finalGraph, functionRootId, forceArgs, patchData }: ProcessAllArgumentInput<OtherInfo>): ProcessAllArgumentResult;
 export interface PatchFunctionCallInput<OtherInfo> {
     readonly nextGraph: DataflowGraph;
@@ -39,4 +42,7 @@ export interface PatchFunctionCallInput<OtherInfo> {
     readonly origin: FunctionOriginInformation;
     readonly link?: DataflowGraphVertexAstLink;
 }
+/**
+ *
+ */
 export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }: PatchFunctionCallInput<OtherInfo>): void;

package/dataflow/internal/process/functions/call/common.js

@@ -43,7 +43,10 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
         }
     }
 }
-function processAllArguments({ functionName, args, data, finalGraph, functionRootId, forceArgs = [], patchData = d => d }) {
+/**
+ * Processes all arguments for a function call, updating the given final graph and environment.
+ */
+function processAllArguments({ functionName, args, data, finalGraph, functionRootId, forceArgs = [], patchData }) {
     let finalEnv = functionName.environment;
     // arg env contains the environments with other args defined
     let argEnv = functionName.environment;
@@ -53,7 +56,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
     let i = -1;
     for (const arg of args) {
         i++;
-        data = patchData(data, i);
+        data = patchData?.(data, i) ?? data;
         if (arg === r_function_call_1.EmptyArgument) {
             callArgs.push(r_function_call_1.EmptyArgument);
             processedArguments.push(undefined);
@@ -67,7 +70,7 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
         finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
         finalGraph.mergeWith(processed.graph);
         // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies
-        for (const ingoing of [...processed.in, ...processed.unknownReferences]) {
+        for (const ingoing of processed.in.concat(processed.unknownReferences)) {
             // check if it is called directly
             const vtx = finalGraph.getVertex(ingoing.nodeId);
             const tryToResolve = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, argEnv, vtx?.tag === vertex_1.VertexType.FunctionCall ? identifier_1.ReferenceType.Function : identifier_1.ReferenceType.Unknown) : undefined;
@@ -104,6 +107,9 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
     }
     return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
 }
+/**
+ *
+ */
 function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }) {
     nextGraph.addVertex({
         tag: vertex_1.VertexType.FunctionCall,

package/dataflow/internal/process/functions/call/default-call-handling.d.ts

@@ -2,4 +2,9 @@ import type { DataflowInformation } from '../../../../info';
 import type { DataflowProcessorInformation } from '../../../../processor';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+/**
+ * Processes a function call, either named or unnamed.
+ * @see {@link processNamedCall}
+ * @see {@link processUnnamedFunctionCall}
+ */
 export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/default-call-handling.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFunctionCall = processFunctionCall;
 const named_call_handling_1 = require("./named-call-handling");
 const unnamed_call_handling_1 = require("./unnamed-call-handling");
+/**
+ * Processes a function call, either named or unnamed.
+ * @see {@link processNamedCall}
+ * @see {@link processUnnamedFunctionCall}
+ */
 function processFunctionCall(functionCall, data) {
     if (functionCall.named) {
         return (0, named_call_handling_1.processNamedCall)(functionCall.functionName, functionCall.arguments, functionCall.info.id, data);

package/dataflow/internal/process/functions/call/known-call-handling.d.ts

@@ -1,14 +1,14 @@
-import type { DataflowProcessorInformation } from '../../../../processor';
-import type { DataflowInformation } from '../../../../info';
-import type { ForceArguments } from './common';
+import { type DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowInformation } from '../../../../info';
+import { type ForceArguments } from './common';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 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 { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
-import type { IdentifierReference } from '../../../../environments/identifier';
+import { type IdentifierReference } from '../../../../environments/identifier';
 import { DataflowGraph } from '../../../../graph/graph';
-import type { ContainerIndicesCollection, FunctionOriginInformation } from '../../../../graph/vertex';
+import { type ContainerIndicesCollection, type FunctionOriginInformation } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
@@ -29,5 +29,12 @@ export interface ProcessKnownFunctionCallResult {
     readonly processedArguments: readonly (DataflowInformation | undefined)[];
     readonly fnRef: IdentifierReference;
 }
+/**
+ * Marks the given arguments as being involved in R's non-standard evaluation.
+ */
 export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
+/**
+ * The main processor for function calls for which we know the target but need not
+ * add any specific handling.
+ */
 export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect, origin }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -11,6 +11,9 @@ const logger_1 = require("../../../../logger");
 const vertex_1 = require("../../../../graph/vertex");
 const log_1 = require("../../../../../util/log");
 const unknown_side_effect_1 = require("../../../../graph/unknown-side-effect");
+/**
+ * Marks the given arguments as being involved in R's non-standard evaluation.
+ */
 function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
     for (const nse of markAsNSE) {
         if (nse < callArgs.length) {
@@ -24,12 +27,16 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
         }
     }
 }
+/**
+ * The main processor for function calls for which we know the target but need not
+ * add any specific handling.
+ */
 function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect, origin }, indicesCollection = undefined) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${functionCallName} with ${args.length} arguments`);
-    const processArgs = reverseOrder ? [...args].reverse() : args;
+    const processArgs = reverseOrder ? args.toReversed() : args;
     const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
     if (markAsNSE) {
         markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
@@ -42,7 +49,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         /* will be overwritten accordingly */
         onlyBuiltin: false,
         cds: data.controlDependencies,
-        args: reverseOrder ? [...callArgs].reverse() : callArgs,
+        args: reverseOrder ? callArgs.reverse() : callArgs,
         indicesCollection: indicesCollection,
         origin: origin === 'default' ? ['function'] : [origin]
     });
@@ -63,7 +70,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
             entryPoint: rootId,
             exitPoints: [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
         },
-        processedArguments: reverseOrder ? [...processedArguments].reverse() : processedArguments,
+        processedArguments: reverseOrder ? processedArguments.reverse() : processedArguments,
         fnRef
     };
 }

package/dataflow/internal/process/functions/call/named-call-handling.d.ts

@@ -1,9 +1,15 @@
 import type { DataflowProcessorInformation } from '../../../../processor';
-import type { DataflowInformation } from '../../../../info';
+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';
 import type { DataflowGraph } from '../../../../graph/graph';
+/**
+ * Marks the given function call node as only calling built-in functions.
+ */
 export declare function markAsOnlyBuiltIn(graph: DataflowGraph, rootId: NodeId): void;
+/**
+ * Processes a named function call within the dataflow analysis.
+ */
 export declare function processNamedCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/named-call-handling.js

@@ -13,13 +13,13 @@ function mergeInformation(info, newInfo) {
         return newInfo;
     }
     return {
-        unknownReferences: [...info.unknownReferences, ...newInfo.unknownReferences],
-        in: [...info.in, ...newInfo.in],
-        out: [...info.out, ...newInfo.out],
+        unknownReferences: info.unknownReferences.concat(newInfo.unknownReferences),
+        in: info.in.concat(newInfo.in),
+        out: info.out.concat(newInfo.out),
         graph: info.graph.mergeWith(newInfo.graph),
         environment: (0, append_1.appendEnvironment)(info.environment, newInfo.environment),
         entryPoint: newInfo.entryPoint,
-        exitPoints: [...info.exitPoints, ...newInfo.exitPoints],
+        exitPoints: info.exitPoints.concat(newInfo.exitPoints),
     };
 }
 function processDefaultFunctionProcessor(information, name, args, rootId, data) {
@@ -28,6 +28,9 @@ function processDefaultFunctionProcessor(information, name, args, rootId, data)
     const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all', origin: 'default' });
     return mergeInformation(information, call.information);
 }
+/**
+ * Marks the given function call node as only calling built-in functions.
+ */
 function markAsOnlyBuiltIn(graph, rootId) {
     const v = graph.getVertex(rootId);
     if (v?.tag === vertex_1.VertexType.FunctionCall) {
@@ -35,6 +38,9 @@ function markAsOnlyBuiltIn(graph, rootId) {
         v.environment = undefined;
     }
 }
+/**
+ * Processes a named function call within the dataflow analysis.
+ */
 function processNamedCall(name, args, rootId, data) {
     const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
     let defaultProcessor = resolved.length === 0;

package/dataflow/internal/process/functions/call/unnamed-call-handling.d.ts

@@ -1,7 +1,10 @@
-import type { DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowProcessorInformation } from '../../../../processor';
 import type { DataflowInformation } from '../../../../info';
 import type { RUnnamedFunctionCall } 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';
 export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
 export declare const UnnamedFunctionCallOrigin = "unnamed";
+/**
+ *
+ */
 export declare function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/unnamed-call-handling.js

@@ -13,6 +13,9 @@ const logger_1 = require("../../../../logger");
 const identifier_1 = require("../../../../environments/identifier");
 exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
 exports.UnnamedFunctionCallOrigin = 'unnamed';
+/**
+ *
+ */
 function processUnnamedFunctionCall(functionCall, data) {
     const calledFunction = (0, processor_1.processDataflowFor)(functionCall.calledFunction, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);