@eagleoutice/flowr 2.0.16 → 2.0.17

package/dataflow/info.d.ts

@@ -57,7 +57,7 @@ export interface DataflowInformation extends DataflowCfgInformation {
     graph: DataflowGraph;
 }
 export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
-export declare function happensInEveryBranch(controlDependencies: ControlDependency[] | undefined): boolean;
+export declare function happensInEveryBranch(controlDependencies: readonly ControlDependency[] | undefined): boolean;
 export declare function alwaysExits(data: DataflowInformation): boolean;
 export declare function filterOutLoopExitPoints(exitPoints: readonly ExitPoint[]): readonly ExitPoint[];
 export declare function diffControlDependency<Report extends WriteableDifferenceReport>(a: ControlDependency | undefined, b: ControlDependency | undefined, info: GenericDifferenceInformation<Report>): void;

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

@@ -4,6 +4,7 @@ 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 processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     treatIndicesAsString: boolean;
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

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

@@ -9,13 +9,13 @@ const environment_1 = require("../../../../../environments/environment");
 function processAccess(name, args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Access ${name.content} has less 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 head = args[0];
     (0, assert_1.guard)(head !== r_function_call_1.EmptyArgument, () => `Access ${name.content} has no source, impossible!`);
     let fnCall;
     if (!config.treatIndicesAsString) {
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
     }
     else {
         const newArgs = [...args];
@@ -38,7 +38,7 @@ function processAccess(name, args, rootId, data, config) {
                 };
             }
         }
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
     }
     const info = fnCall.information;
     info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, { type: 8 /* EdgeType.Returns */ });

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

@@ -5,7 +5,8 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-export interface AssignmentConfiguration {
+import type { ForceArguments } from '../common';
+export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
     readonly makeMaybe?: boolean;

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

@@ -35,13 +35,13 @@ function processAssignment(name,
 args, rootId, data, config) {
     if (args.length != 2) {
         logger_1.dataflowLogger.warn(`Assignment ${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 effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
     const { type, named } = target;
     if (type === "RSymbol" /* RType.Symbol */) {
-        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget });
+        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs });
         return processAssignmentToSymbol({
             ...config,
             name,
@@ -68,7 +68,7 @@ args, rootId, data, config) {
         return processAssignmentToString(target, args, name, rootId, data, config, source);
     }
     logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type}, skipping`);
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs }).information;
 }
 exports.processAssignment = processAssignment;
 function extractSourceAndTarget(args, name) {
@@ -105,7 +105,8 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         args: mappedArgs,
         rootId,
         data,
-        reverseOrder: !config.swapSourceAndTarget
+        reverseOrder: !config.swapSourceAndTarget,
+        forceArgs: config.forceArgs
     });
     return processAssignmentToSymbol({
         ...config,

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

@@ -63,7 +63,7 @@ function processForLoop(name, args, rootId, data) {
             for (const readId of readIdsToLink) {
                 nextGraph.addEdge(readId.nodeId, write.nodeId, { type: 1 /* EdgeType.Reads */ });
             }
-            // now, we remove the name from the id shares as they are no longer needed
+            // now, we remove the name from the id shares as they are no longer necessary
             nameIdShares.delete(name);
             nextGraph.setDefinitionOfVertex(write);
         }

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

@@ -45,8 +45,17 @@ function processFunctionDefinition(name, args, rootId, data) {
     const readInBody = [...body.in, ...body.unknownReferences];
     // there is no uncertainty regarding the arguments, as if a function header is executed, so is its body
     const remainingRead = (0, linker_1.linkInputs)(readInBody, paramsEnvironments, readInParameters.slice(), body.graph, true /* functions do not have to be called */);
+    // functions can be called multiple times,
+    // so if they have a global effect, we have to link them as if they would be executed a loop
+    /* theoretically, we should just check if there is a global effect-write somewhere within */
+    if (remainingRead.length > 0) {
+        const nameIdShares = (0, linker_1.produceNameSharedIdMap)(remainingRead);
+        const definedInLocalEnvironment = new Set([...bodyEnvironment.current.memory.values()].flat().map(d => d.nodeId));
+        // Everything that is in body.out but not within the local environment populated for the function scope is a potential escape ~> global definition
+        const globalBodyOut = body.out.filter(d => !definedInLocalEnvironment.has(d.nodeId));
+        (0, linker_1.linkCircularRedefinitionsWithinALoop)(body.graph, nameIdShares, globalBodyOut);
+    }
     subgraph.mergeWith(body.graph);
-    logger_1.dataflowLogger.trace(`Function definition with id ${name.info.id} has ${remainingRead.length} remaining reads`);
     const outEnvironment = (0, overwrite_1.overwriteEnvironment)(paramsEnvironments, bodyEnvironment);
     for (const read of remainingRead) {
         if (read.name) {

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

@@ -33,23 +33,23 @@ function processIfThenElse(name, args, rootId, data) {
     // we should defer this to the abstract interpretation
     const conditionIsFalse = (0, resolve_by_name_1.resolvesToBuiltInConstant)(condArg?.lexeme, data.environment, false);
     const conditionIsTrue = (0, resolve_by_name_1.resolvesToBuiltInConstant)(condArg?.lexeme, data.environment, true);
-    if (conditionIsFalse !== 'always') {
+    if (conditionIsFalse !== 0 /* Ternary.Always */) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {
             then.graph.addEdge(name.info.id, then.entryPoint, { type: 8 /* EdgeType.Returns */ });
         }
-        if (conditionIsTrue !== 'always') {
+        if (conditionIsTrue !== 0 /* Ternary.Always */) {
             makeThenMaybe = true;
         }
     }
     let otherwise;
     let makeOtherwiseMaybe = false;
-    if (otherwiseArg !== undefined && conditionIsTrue !== 'always') {
+    if (otherwiseArg !== undefined && conditionIsTrue !== 0 /* Ternary.Always */) {
         otherwise = (0, processor_1.processDataflowFor)(otherwiseArg, data);
         if (otherwise.entryPoint) {
             otherwise.graph.addEdge(name.info.id, otherwise.entryPoint, { type: 8 /* EdgeType.Returns */ });
         }
-        if (conditionIsFalse !== 'always') {
+        if (conditionIsFalse !== 0 /* Ternary.Always */) {
             makeOtherwiseMaybe = true;
         }
     }

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

@@ -5,6 +5,7 @@ const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const make_argument_1 = require("../argument/make-argument");
+/* we currently do not mark this as an unknown side effect, as we can enable/disable this with a toggle */
 function processLibrary(name, args, rootId, data) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Currently only one-arg library-likes are allows (for ${name.content}), skipping`);

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

@@ -4,6 +4,7 @@ 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';
-export declare function processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config?: {
+import type { ForceArguments } from '../common';
+export declare function processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     quoteArgumentsWithIndex?: number;
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processQuote = void 0;
 const known_call_handling_1 = require("../known-call-handling");
 function processQuote(name, args, rootId, data, config) {
-    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
     const inRefs = [fnRef];
     const outRefs = [];
     const unknownRefs = [];

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,7 +8,7 @@ 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;
@@ -23,4 +24,4 @@ export interface ProcessKnownFunctionCallResult {
     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 processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData }: ProcessKnownFunctionCallInput<OtherInfo>): ProcessKnownFunctionCallResult;

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

@@ -22,13 +22,13 @@ 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 }) {
     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`);
     const processArgs = reverseOrder ? [...args].reverse() : args;
-    const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData });
+    const { finalEnv, callArgs, remainingReadInArgs, processedArguments } = (0, common_1.processAllArguments)({ functionName, args: processArgs, data, finalGraph, functionRootId: rootId, patchData, forceArgs });
     markNonStandardEvaluationEdges(markAsNSE, processedArguments, finalGraph, rootId);
     finalGraph.addVertex({
         tag: "function-call" /* VertexType.FunctionCall */,

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.17",
   "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";

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',

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}`);