@eagleoutice/flowr 2.0.16 → 2.0.18

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

@@ -1,12 +1,13 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
+import type { ForceArguments } from '../common';
 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 { 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';
 export declare function processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
-/** last one has to be the value */
+/** The last one has to be the value */
 args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     makeMaybe?: boolean;
     assignmentOperator?: '<-' | '<<-';
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

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

@@ -11,7 +11,7 @@ const logger_1 = require("../../../../../logger");
 const graph_1 = require("../../../../../graph/graph");
 const dfg_1 = require("../../../../../../util/mermaid/dfg");
 function processReplacementFunction(name, 
-/** last one has to be the value */
+/** The last one has to be the value */
 args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Replacement ${name.content} has less than 2 arguments, skipping`);
@@ -28,6 +28,7 @@ args, rootId, data, config) {
         data,
         functionRootId: rootId,
         finalGraph: res.graph,
+        forceArgs: config.forceArgs,
     });
     const fn = res.graph.getVertex(rootId, true);
     (0, assert_1.guard)(fn?.tag === "function-call" /* VertexType.FunctionCall */ && fn.args.length === 2, () => `Function ${rootId} not found in graph or not 2-arg fn-call (${JSON.stringify(fn)}) ${(0, dfg_1.graphToMermaidUrl)(res.graph)}`);

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

@@ -10,8 +10,8 @@ export declare function setSourceProvider(provider: RParseRequestProvider): void
 export declare function processSourceCall<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;
-    /** should this function call be followed, even when the configuratio disables it? */
+    /** should this function call be followed, even when the configuration disables it? */
     forceFollow?: boolean;
 }): DataflowInformation;
-export declare function sourceRequest<OtherInfo>(request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;
+export declare function sourceRequest<OtherInfo>(rootId: NodeId, request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;
 export declare function standaloneSourceFile<OtherInfo>(inputRequest: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, uniqueSourceId: string, information: DataflowInformation): DataflowInformation;

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

@@ -12,6 +12,7 @@ const decorate_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/proces
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const logger_1 = require("../../../../../logger");
 const overwrite_1 = require("../../../../../environments/overwrite");
+const log_1 = require("../../../../../../util/log");
 let sourceProvider = (0, retriever_1.requestProviderFromFile)();
 function setSourceProvider(provider) {
     sourceProvider = provider;
@@ -23,26 +24,29 @@ function processSourceCall(name, args, rootId, data, config) {
         : (0, info_1.initializeCleanDataflowInformation)(rootId, data);
     const sourceFile = args[0];
     if (!config.forceFollow && (0, config_1.getConfig)().ignoreSourceCalls) {
-        logger_1.dataflowLogger.info(`Skipping source call ${JSON.stringify(sourceFile)} (disabled in config file)`);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping source call ${JSON.stringify(sourceFile)} (disabled in config file)`);
+        information.graph.markIdForUnknownSideEffects(rootId);
         return information;
     }
-    if (sourceFile !== r_function_call_1.EmptyArgument && sourceFile?.value?.type == "RString" /* RType.String */) {
+    if (sourceFile !== r_function_call_1.EmptyArgument && sourceFile?.value?.type === "RString" /* RType.String */) {
         const path = (0, retriever_1.removeRQuotes)(sourceFile.lexeme);
         const request = sourceProvider.createRequest(path);
         // check if the sourced file has already been dataflow analyzed, and if so, skip it
         if (data.referenceChain.includes((0, retriever_1.requestFingerprint)(request))) {
-            logger_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            information.graph.markIdForUnknownSideEffects(rootId);
             return information;
         }
-        return sourceRequest(request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)(path, name.location));
+        return sourceRequest(rootId, request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)(path, name.location));
     }
     else {
-        logger_1.dataflowLogger.info(`Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
+        (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
+        information.graph.markIdForUnknownSideEffects(rootId);
         return information;
     }
 }
 exports.processSourceCall = processSourceCall;
-function sourceRequest(request, data, information, getId) {
+function sourceRequest(rootId, request, data, information, getId) {
     const executor = new shell_executor_1.RShellExecutor();
     // parse, normalize and dataflow the sourced file
     let normalized;
@@ -59,8 +63,14 @@ function sourceRequest(request, data, information, getId) {
     }
     catch (e) {
         logger_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
+        information.graph.markIdForUnknownSideEffects(rootId);
         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
+    dataflow.graph.addControlDependency(dataflow.entryPoint, rootId);
+    for (const out of dataflow.out) {
+        dataflow.graph.addControlDependency(out.nodeId, rootId);
+    }
     // update our graph with the sourced file's information
     const newInformation = { ...information };
     newInformation.environment = (0, overwrite_1.overwriteEnvironment)(information.environment, dataflow.environment);
@@ -80,9 +90,10 @@ function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
     // check if the sourced file has already been dataflow analyzed, and if so, skip it
     if (data.referenceChain.includes(fingerprint)) {
         logger_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+        information.graph.markIdForUnknownSideEffects(uniqueSourceId);
         return information;
     }
-    return sourceRequest(request, {
+    return sourceRequest(uniqueSourceId, request, {
         ...data,
         currentRequest: request,
         environment: information.environment,

package/dataflow/internal/process/functions/call/built-in/{built-in-logical-bin-op.d.ts → built-in-special-bin-op.d.ts}

@@ -4,7 +4,8 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 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';
 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;
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/{built-in-logical-bin-op.js → built-in-special-bin-op.js}

@@ -9,9 +9,9 @@ function processSpecialBinOp(name, args, rootId, data, config) {
     }
     else if (args.length != 2) {
         logger_1.dataflowLogger.warn(`Logical bin-op ${name.content} has something else than 2 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
     }
-    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data,
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs,
         patchData: (d, i) => {
             if (i === 1) {
                 return { ...d, controlDependencies: [...d.controlDependencies ?? [], { id: name.info.id, when: config.evalRhsWhen }] };
@@ -31,4 +31,4 @@ function processSpecialBinOp(name, args, rootId, data, config) {
     return information;
 }
 exports.processSpecialBinOp = processSpecialBinOp;
-//# sourceMappingURL=built-in-logical-bin-op.js.map
+//# sourceMappingURL=built-in-special-bin-op.js.map

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

@@ -8,7 +8,11 @@ import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processi
 import type { REnvironmentInformation } from '../../../../environments/environment';
 import type { IdentifierReference } from '../../../../environments/identifier';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-export interface ProcessAllArgumentInput<OtherInfo> {
+export interface ForceArguments {
+    /** which of the arguments should be forced? this may be all, e.g., if the function itself is unknown on encounter */
+    readonly forceArgs?: 'all' | readonly boolean[];
+}
+export interface ProcessAllArgumentInput<OtherInfo> extends ForceArguments {
     readonly functionName: DataflowInformation;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
@@ -24,7 +28,7 @@ export interface ProcessAllArgumentResult {
     readonly remainingReadInArgs: IdentifierReference[];
     readonly processedArguments: (DataflowInformation | undefined)[];
 }
-export declare function processAllArguments<OtherInfo>({ functionName, args, data, finalGraph, functionRootId, patchData }: ProcessAllArgumentInput<OtherInfo>): ProcessAllArgumentResult;
+export declare function processAllArguments<OtherInfo>({ functionName, args, data, finalGraph, functionRootId, forceArgs, patchData }: ProcessAllArgumentInput<OtherInfo>): ProcessAllArgumentResult;
 export interface PatchFunctionCallInput<OtherInfo> {
     readonly nextGraph: DataflowGraph;
     readonly rootId: NodeId;

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

@@ -5,7 +5,39 @@ const processor_1 = require("../../../../processor");
 const r_function_call_1 = require("../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const overwrite_1 = require("../../../../environments/overwrite");
 const resolve_by_name_1 = require("../../../../environments/resolve-by-name");
-function processAllArguments({ functionName, args, data, finalGraph, functionRootId, patchData = d => d }) {
+const vertex_1 = require("../../../../graph/vertex");
+function forceVertexArgumentValueReferences(rootId, value, graph, env) {
+    const valueVertex = graph.getVertex(value.entryPoint);
+    if (!valueVertex) {
+        return;
+    }
+    // link read if it is function definition directly and reference the exit point
+    if (valueVertex.tag !== "value" /* VertexType.Value */) {
+        if (valueVertex.tag === "function-definition" /* VertexType.FunctionDefinition */) {
+            for (const exit of valueVertex.exitPoints) {
+                graph.addEdge(rootId, exit, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+        else {
+            for (const exit of value.exitPoints) {
+                graph.addEdge(rootId, exit.nodeId, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+    }
+    const containedSubflowIn = [...graph.vertices(true)]
+        .filter(([, info]) => (0, vertex_1.isFunctionDefinitionVertex)(info))
+        .flatMap(([, info]) => info);
+    // try to resolve them against the current environment
+    for (const ref of [...value.in, ...containedSubflowIn.flatMap(n => n.subflow.in)]) {
+        if (ref.name) {
+            const resolved = (0, resolve_by_name_1.resolveByName)(ref.name, env) ?? [];
+            for (const resolve of resolved) {
+                graph.addEdge(ref.nodeId, resolve.nodeId, { type: 1 /* EdgeType.Reads */ });
+            }
+        }
+    }
+}
+function processAllArguments({ functionName, args, data, finalGraph, functionRootId, forceArgs = [], patchData = d => d }) {
     let finalEnv = functionName.environment;
     // arg env contains the environments with other args defined
     let argEnv = functionName.environment;
@@ -22,6 +54,9 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
             continue;
         }
         const processed = (0, processor_1.processDataflowFor)(arg, { ...data, environment: argEnv });
+        if (arg.type === "RArgument" /* RType.Argument */ && arg.value && (forceArgs === 'all' || forceArgs[i]) && arg.value.type !== "RNumber" /* RType.Number */ && arg.value.type !== "RString" /* RType.String */ && arg.value.type !== "RLogical" /* RType.Logical */) {
+            forceVertexArgumentValueReferences(functionRootId, processed, processed.graph, argEnv);
+        }
         processedArguments.push(processed);
         finalEnv = (0, overwrite_1.overwriteEnvironment)(finalEnv, processed.environment);
         // resolve reads within argument, we resolve before adding the `processed.environment` to avoid cyclic dependencies

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

@@ -1,5 +1,6 @@
 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';
@@ -7,20 +8,24 @@ import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processi
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { IdentifierReference } from '../../../../environments/identifier';
 import { DataflowGraph } from '../../../../graph/graph';
-export interface ProcessKnownFunctionCallInput<OtherInfo> {
+export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
     readonly rootId: NodeId;
     readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    /** should arguments be processed from right to left? This does not affect the order recorded in the call but of the environments */
     readonly reverseOrder?: boolean;
     /** which arguments are to be marked as {@link EdgeType#NonStandardEvaluation|non-standard-evaluation}? */
     readonly markAsNSE?: readonly number[];
+    /** allows passing a data processor in-between each argument */
     readonly patchData?: (data: DataflowProcessorInformation<OtherInfo & ParentInformation>, arg: number) => DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    /** Does the call have a side effect that we do not know a lot about which may have further consequences? */
+    readonly hasUnknownSideEffect?: boolean;
 }
 export interface ProcessKnownFunctionCallResult {
     readonly information: DataflowInformation;
     readonly processedArguments: readonly (DataflowInformation | undefined)[];
     readonly fnRef: IdentifierReference;
 }
-export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[] | undefined, callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
-export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, patchData }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;
+export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
+export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;

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

@@ -5,10 +5,8 @@ const processor_1 = require("../../../../processor");
 const common_1 = require("./common");
 const graph_1 = require("../../../../graph/graph");
 const logger_1 = require("../../../../logger");
+const log_1 = require("../../../../../util/log");
 function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
-    if (markAsNSE === undefined) {
-        return;
-    }
     for (const nse of markAsNSE) {
         if (nse < callArgs.length) {
             const arg = callArgs[nse];
@@ -22,14 +20,16 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
     }
 }
 exports.markNonStandardEvaluationEdges = markNonStandardEvaluationEdges;
-function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, patchData = d => d }) {
+function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect }) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);
     const functionCallName = name.content;
-    logger_1.dataflowLogger.debug(`Using ${rootId} (name: ${functionCallName}) as root for the named function call`);
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Processing known function call ${functionCallName} with ${args.length} arguments`);
     const processArgs = reverseOrder ? [...args].reverse() : args;
-    const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData });
-    markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
+    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);
+    }
     finalGraph.addVertex({
         tag: "function-call" /* VertexType.FunctionCall */,
         id: rootId,
@@ -40,6 +40,9 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         controlDependencies: data.controlDependencies,
         args: reverseOrder ? [...callArgs].reverse() : callArgs
     });
+    if (hasUnknownSideEffect) {
+        finalGraph.markIdForUnknownSideEffects(rootId);
+    }
     const inIds = remainingReadInArgs;
     const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, call: true };
     inIds.push(fnRef);

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

@@ -20,7 +20,9 @@ function mergeInformation(info, newInfo) {
     };
 }
 function processDefaultFunctionProcessor(information, name, args, rootId, data) {
-    const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const resolve = (0, resolve_by_name_1.resolveByName)(name.content, data.environment);
+    /* if we do not know where we land, we force! */
+    const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all' });
     return mergeInformation(information, call.information);
 }
 function processNamedCall(name, args, rootId, data) {

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

@@ -25,6 +25,7 @@ function processUnnamedFunctionCall(functionCall, data) {
         data,
         finalGraph,
         functionRootId
+        /* we know the call is right there and fully resolved, there is no need to artificially force arguments as we identify them within the subtree */
     });
     finalGraph.addVertex({
         tag: "function-call" /* VertexType.FunctionCall */,

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

@@ -4,8 +4,6 @@ exports.processFunctionArgument = exports.linkReadsForArgument = void 0;
 const processor_1 = require("../../../processor");
 const collect_1 = require("../../../../r-bridge/lang-4.x/ast/model/collect");
 const graph_1 = require("../../../graph/graph");
-const edge_1 = require("../../../graph/edge");
-const resolve_by_name_1 = require("../../../environments/resolve-by-name");
 function linkReadsForArgument(root, ingoingRefs, graph) {
     const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
     const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
@@ -15,18 +13,6 @@ function linkReadsForArgument(root, ingoingRefs, graph) {
     }
 }
 exports.linkReadsForArgument = linkReadsForArgument;
-function hasNoOutgoingCallEdge(graph, id) {
-    const outgoings = graph.outgoingEdges(id);
-    if (outgoings === undefined) {
-        return true;
-    }
-    for (const [_, edge] of outgoings) {
-        if ((0, edge_1.edgeIncludesType)(edge.types, 4 /* EdgeType.Calls */)) {
-            return false;
-        }
-    }
-    return true;
-}
 function processFunctionArgument(argument, data) {
     const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
     const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);
@@ -43,20 +29,6 @@ function processFunctionArgument(argument, data) {
         entryPoint = argument.info.id;
     }
     const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
-    /* potentially link all function calls here (as maybes with a maybe cd) as the called function may employ calling-env-semantics if unknown */
-    if (value) {
-        const functionCalls = [...graph.vertices(true)]
-            .filter(([_, info]) => info.tag === "function-call" /* VertexType.FunctionCall */)
-            .filter(([id]) => hasNoOutgoingCallEdge(graph, id));
-        // try to resolve them against the current environment
-        for (const [id, info] of functionCalls) {
-            const resolved = (0, resolve_by_name_1.resolveByName)(info.name, data.environment) ?? [];
-            /* first, only link a read ref */
-            for (const resolve of resolved) {
-                graph.addEdge(id, resolve.nodeId, { type: 1 /* EdgeType.Reads */ });
-            }
-        }
-    }
     if (entryPoint && argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
         graph.addEdge(entryPoint, argument.value.info.id, { type: 1 /* EdgeType.Reads */ });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -33,7 +33,8 @@
     "doc": "typedoc",
     "test": "nyc --no-clean mocha",
     "performance-test": "func() { cd test/performance/ && bash run-all-suites.sh $1 $2 $3; cd ../../; }; func",
-    "test-full": "npm run test -- --test-installation"
+    "test-full": "npm run test -- --test-installation",
+    "detect-circular-deps": "npx madge  --extensions ts,tsx --circular src/"
   },
   "keywords": [
     "static code analysis",

package/r-bridge/data/data.d.ts

@@ -146,6 +146,11 @@ export declare const flowrCapabilities: {
                 readonly id: "redefinition-of-built-in-functions-primitives";
                 readonly supported: "partially";
                 readonly description: "_Handle cases like `print <- function(x) x`, `` `for` <- function(a,b,c) a``, ..._ Currently, we can not handle all of them there are no tests. Still wip as part of desugaring";
+            }, {
+                readonly name: "Functions with global side effects";
+                readonly id: "functions-with-global-side-effects";
+                readonly supported: "partially";
+                readonly description: "_Support functions like `setwd` which have an impact on the subsequent program._";
             }, {
                 readonly name: "Index Access";
                 readonly id: "index-access";
@@ -226,6 +231,11 @@ export declare const flowrCapabilities: {
                             readonly id: "local-equal-assignment";
                             readonly supported: "fully";
                             readonly description: "_Handle `x = 3`, `x$y := 3`, ..._";
+                        }, {
+                            readonly name: "Local Table Assignment";
+                            readonly id: "local-table-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x[,a:=3,]`, ..._";
                         }, {
                             readonly name: "Super Left Assignment";
                             readonly id: "super-left-assignment";

package/r-bridge/data/data.js

@@ -184,6 +184,12 @@ exports.flowrCapabilities = {
                             supported: 'partially',
                             description: '_Handle cases like `print <- function(x) x`, `` `for` <- function(a,b,c) a``, ..._ Currently, we can not handle all of them there are no tests. Still wip as part of desugaring'
                         },
+                        {
+                            name: 'Functions with global side effects',
+                            id: 'functions-with-global-side-effects',
+                            supported: 'partially',
+                            description: '_Support functions like `setwd` which have an impact on the subsequent program._'
+                        },
                         {
                             name: 'Index Access',
                             id: 'index-access',
@@ -282,6 +288,12 @@ exports.flowrCapabilities = {
                                                     supported: 'fully',
                                                     description: '_Handle `x = 3`, `x$y := 3`, ..._'
                                                 },
+                                                {
+                                                    name: 'Local Table Assignment',
+                                                    id: 'local-table-assignment',
+                                                    supported: 'fully',
+                                                    description: '_Handle `x[,a:=3,]`, ..._'
+                                                },
                                                 {
                                                     name: 'Super Left Assignment',
                                                     id: 'super-left-assignment',

package/r-bridge/lang-4.x/ast/model/operators.js

@@ -34,7 +34,7 @@ exports.OperatorDatabase = {
     '%in%': { name: 'matching operator', stringUsedInRAst: '%in%', stringUsedInternally: '%in%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
     /* assignment */
     '<-': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-left-assignment', 'function-calls'] },
-    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls'] },
+    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-table-assignment', 'function-calls'] },
     '<<-': { name: 'left global assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-left-assignment', 'function-calls'] },
     '->': { name: 'right assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-right-assignment', 'function-calls'] },
     '->>': { name: 'right global assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->>', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-right-assignment', 'function-calls'] },

package/reconstruct/auto-select/auto-select-defaults.d.ts

@@ -1,4 +1,4 @@
-import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /**
  * The structure of the predicate that should be used to determine
@@ -14,8 +14,3 @@ export type AutoSelectPredicate = (node: RNode<ParentInformation>, fullAst: Norm
  * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~&gt; false)
  */
 export declare function doNotAutoSelect(_node: RNode): boolean;
-/**
- * A variant of the {@link AutoSelectPredicate} which does its best
- * to select any kind of library import automatically.
- */
-export declare function autoSelectLibrary<Info = NoInfo>(node: RNode<Info>): boolean;

package/reconstruct/auto-select/auto-select-defaults.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.autoSelectLibrary = exports.doNotAutoSelect = void 0;
+exports.doNotAutoSelect = void 0;
 /**
  * A variant of the {@link AutoSelectPredicate} which does not select any additional statements (~> false)
  */
@@ -8,16 +8,4 @@ function doNotAutoSelect(_node) {
     return false;
 }
 exports.doNotAutoSelect = doNotAutoSelect;
-const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
-/**
- * A variant of the {@link AutoSelectPredicate} which does its best
- * to select any kind of library import automatically.
- */
-function autoSelectLibrary(node) {
-    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || !node.named) {
-        return false;
-    }
-    return libraryFunctionCall.test(node.functionName.content);
-}
-exports.autoSelectLibrary = autoSelectLibrary;
 //# sourceMappingURL=auto-select-defaults.js.map

package/reconstruct/reconstruct.js

@@ -424,7 +424,7 @@ function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
  *
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
-function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.autoSelectLibrary) {
+function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.doNotAutoSelect) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
         exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
     }

package/slicing/criterion/parse.d.ts

@@ -1,6 +1,5 @@
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Either `line:column`, `line@variable-name`, or `$id` */
 export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${number}`;
 export type SlicingCriteria = SingleSlicingCriterion[];
@@ -13,10 +12,10 @@ export declare class CriteriaParseError extends Error {
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
  */
-export declare function slicingCriterionToId<OtherInfo = NoInfo>(criterion: SingleSlicingCriterion, decorated: NormalizedAst<OtherInfo & ParentInformation>): NodeId;
+export declare function slicingCriterionToId(criterion: SingleSlicingCriterion, idMap: AstIdMap): NodeId;
 export interface DecodedCriterion {
     criterion: SingleSlicingCriterion;
     id: NodeId;
 }
 export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;
-export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: NormalizedAst): DecodedCriteria;
+export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: AstIdMap): DecodedCriteria;

package/slicing/criterion/parse.js

@@ -17,18 +17,18 @@ exports.CriteriaParseError = CriteriaParseError;
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
  */
-function slicingCriterionToId(criterion, decorated) {
+function slicingCriterionToId(criterion, idMap) {
     let resolved;
     if (criterion.startsWith('$')) {
         resolved = (0, node_id_1.normalizeIdToNumberIfPossible)(criterion.substring(1));
     }
     else if (criterion.includes(':')) {
         const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId([line, column], decorated.idMap);
+        resolved = locationToId([line, column], idMap);
     }
     else if (criterion.includes('@')) {
         const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
-        resolved = conventionalCriteriaToId(parseInt(line), name, decorated.idMap);
+        resolved = conventionalCriteriaToId(parseInt(line), name, idMap);
     }
     if (resolved === undefined) {
         throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);

package/slicing/static/static-slicer.d.ts

@@ -13,4 +13,4 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
-export declare function staticSlicing(graph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;
+export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;

package/slicing/static/static-slicer.js

@@ -20,9 +20,9 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @param criteria  - The criteras to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
-function staticSlicing(graph, ast, criteria, threshold = 75) {
+function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
-    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, ast);
+    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
     (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
     const queue = new visiting_queue_1.VisitingQueue(threshold);
     let minDepth = Number.MAX_SAFE_INTEGER;
@@ -34,9 +34,15 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         for (const { id: startId } of decodedCriteria) {
             queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum depth of all nodes to only add control dependencies if they are "part" of the current execution
-            minDepth = Math.min(minDepth, ast.idMap.get(startId)?.info.depth ?? minDepth);
+            minDepth = Math.min(minDepth, idMap.get(startId)?.info.depth ?? minDepth);
             sliceSeedIds.add(startId);
         }
+        /* additionally,
+         * include all the implicit side effects that we have to consider as we are unable to narrow them down
+         */
+        for (const id of graph.unknownSideEffects) {
+            queue.add(id, emptyEnv, basePrint, true);
+        }
     }
     while (queue.nonEmpty()) {
         const current = queue.next();
@@ -52,7 +58,7 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
             for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
-                if (!topLevel || (ast.idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
+                if (!topLevel || (idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }
             }

package/statistics/statistics.js

@@ -64,7 +64,7 @@ function initializeFeatureStatistics() {
     const result = {};
     for (const key of feature_1.allFeatureNames) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        result[key] = JSON.parse(JSON.stringify(feature_1.ALL_FEATURES[key].initialValue, json_1.jsonReplacer), json_1.jsonRetriever);
+        result[key] = JSON.parse(JSON.stringify(feature_1.ALL_FEATURES[key].initialValue, json_1.jsonReplacer), json_1.jsonBigIntRetriever);
     }
     return result;
 }

package/util/json.d.ts

@@ -1,2 +1,2 @@
 export declare function jsonReplacer(key: any, value: any): any;
-export declare function jsonRetriever(key: string, value: unknown): unknown;
+export declare function jsonBigIntRetriever(key: string, value: unknown): unknown;