@eagleoutice/flowr 2.2.14 → 2.2.16

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

@@ -10,7 +10,10 @@ const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const unnamed_call_handling_1 = require("../unnamed-call-handling");
+const general_1 = require("../../../../../eval/values/general");
+const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function processApply(name, args, rootId, data, config) {
     const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
@@ -54,9 +57,9 @@ function processApply(name, args, rootId, data, config) {
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
         if (resolveValue) {
-            const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, data.environment);
-            if (resolved?.length === 1 && typeof resolved[0] === 'string') {
-                functionName = resolved[0];
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables }));
+            if (resolved?.elements.length === 1 && resolved.elements[0].type === 'string') {
+                functionName = (0, r_value_1.isValue)(resolved.elements[0].value) ? resolved.elements[0].value.str : undefined;
             }
         }
         else {
@@ -72,7 +75,7 @@ function processApply(name, args, rootId, data, config) {
         logger_1.dataflowLogger.warn(`Expected symbol or string as function argument at index ${index}, but got ${JSON.stringify(val)} instead.`);
         return information;
     }
-    const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
+    const allOtherArguments = processedArguments.map((arg, i) => {
         const counterpart = args[i];
         if (arg && counterpart !== r_function_call_1.EmptyArgument) {
             return {
@@ -85,7 +88,7 @@ function processApply(name, args, rootId, data, config) {
         else {
             return r_function_call_1.EmptyArgument;
         }
-    });
+    }).filter((_, i) => i !== index);
     if (anonymous) {
         const rootFnId = functionId;
         functionId = 'anon-' + rootFnId;

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

@@ -10,6 +10,7 @@ import type { ContainerIndicesCollection } from '../../../../../graph/vertex';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';
+import type { FlowrConfigOptions } from '../../../../../../config';
 export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
@@ -43,9 +44,10 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param config             - configuration for the assignment processing
+ * @param config             - The flowr config
+ * @param assignmentConfig   - configuration for the assignment processing
  */
 export declare function markAsAssignment(information: {
     environment: REnvironmentInformation;
     graph: DataflowGraph;
-}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, config?: AssignmentConfiguration): void;
+}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, config: FlowrConfigOptions, assignmentConfig?: AssignmentConfiguration): void;

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

@@ -17,9 +17,10 @@ const define_1 = require("../../../../../environments/define");
 const edge_1 = require("../../../../../graph/edge");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const containers_1 = require("../../../../../../util/containers");
-const config_1 = require("../../../../../../config");
 const named_call_handling_1 = require("../named-call-handling");
 const built_in_1 = require("../../../../../environments/built-in");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function toReplacementSymbol(target, prefix, superAssignment) {
     return {
         type: type_1.RType.Symbol,
@@ -142,7 +143,7 @@ args, rootId, data, config) {
         name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs,
         origin: 'builtin:assignment'
     }).information;
-    info.graph.markIdForUnknownSideEffects(rootId);
+    (0, unknown_side_effect_1.handleUnknownSideEffect)(info.graph, info.environment, rootId);
     return info;
 }
 function extractSourceAndTarget(args) {
@@ -214,10 +215,11 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param config             - configuration for the assignment processing
+ * @param config             - The flowr config
+ * @param assignmentConfig   - configuration for the assignment processing
  */
-function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, config) {
-    if ((0, config_1.getConfig)().solver.pointerTracking) {
+function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, config, assignmentConfig) {
+    if (config.solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
             // support for tracking indices.
@@ -233,22 +235,22 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
             }
         }
         // Indices defined by replacement operation e.g. $<-
-        if (config?.indicesCollection !== undefined) {
+        if (assignmentConfig?.indicesCollection !== undefined) {
             // If there were indices stored in the vertex, then a container was defined
             // and assigned to the index of another container e.g. a$b <- list(c = 1)
             if (indicesCollection) {
-                indicesCollection = (0, containers_1.addSubIndicesToLeafIndices)(config.indicesCollection, indicesCollection);
+                indicesCollection = (0, containers_1.addSubIndicesToLeafIndices)(assignmentConfig.indicesCollection, indicesCollection);
             }
             else {
                 // No indices were defined for the vertex e.g. a$b <- 2
-                indicesCollection = config.indicesCollection;
+                indicesCollection = assignmentConfig.indicesCollection;
             }
         }
         nodeToDefine.indicesCollection ??= indicesCollection;
     }
-    information.environment = (0, define_1.define)(nodeToDefine, config?.superAssignment, information.environment);
+    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, config);
     information.graph.setDefinitionOfVertex(nodeToDefine);
-    if (!config?.quoteSource) {
+    if (!assignmentConfig?.quoteSource) {
         for (const sourceId of sourceIds) {
             information.graph.addEdge(nodeToDefine, sourceId, edge_1.EdgeType.DefinedBy);
         }
@@ -269,7 +271,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
 function processAssignmentToSymbol(config) {
     const { nameOfAssignmentFunction, source, args: [targetArg, sourceArg], target, rootId, data, information, makeMaybe, quoteSource } = config;
     const referenceType = checkTargetReferenceType(source, sourceArg);
-    const aliases = (0, resolve_by_name_1.getAliases)([source.info.id], information.graph, information.environment);
+    const aliases = (0, alias_tracking_1.getAliases)([source.info.id], information.graph, information.environment);
     const writeNodes = produceWrittenNodes(rootId, targetArg, referenceType, data, makeMaybe ?? false, aliases);
     if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
         log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
@@ -280,10 +282,10 @@ function processAssignmentToSymbol(config) {
         { nodeId: rootId, name: nameOfAssignmentFunction, controlDependencies: data.controlDependencies, type: identifier_1.ReferenceType.Function },
         ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten
     ];
-    information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
+    information.environment = (0, overwrite_1.overwriteEnvironment)(sourceArg.environment, targetArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {
-        markAsAssignment(information, write, [source.info.id], rootId, config);
+        markAsAssignment(information, write, [source.info.id], rootId, data.flowrConfig, config);
     }
     information.graph.addEdge(rootId, targetArg.entryPoint, edge_1.EdgeType.Returns);
     if (quoteSource) {

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processEvalCall = processEvalCall;
 const info_1 = require("../../../../../info");
-const config_1 = require("../../../../../../config");
 const known_call_handling_1 = require("../known-call-handling");
 const retriever_1 = require("../../../../../../r-bridge/retriever");
 const decorate_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate");
@@ -12,9 +11,12 @@ const log_1 = require("../../../../../../util/log");
 const built_in_source_1 = require("./built-in-source");
 const edge_1 = require("../../../../../graph/edge");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const append_1 = require("../../../../../environments/append");
 const assert_1 = require("../../../../../../util/assert");
+const general_1 = require("../../../../../eval/values/general");
+const string_constants_1 = require("../../../../../eval/values/string/string-constants");
+const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const arrays_1 = require("../../../../../../util/collections/arrays");
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
@@ -28,12 +30,12 @@ function processEvalCall(name, args, rootId, data, config) {
     if (config.includeFunctionCall) {
         information.graph.addEdge(rootId, args[0].value.info.id, edge_1.EdgeType.Returns);
     }
-    if (!(0, config_1.getConfig)().solver.evalStrings) {
+    if (!data.flowrConfig.solver.evalStrings) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
-        information.graph.markIdForUnknownSideEffects(rootId);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
-    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap);
+    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.flowrConfig);
     if (code) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
@@ -62,10 +64,10 @@ function processEvalCall(name, args, rootId, data, config) {
         };
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);
-    information.graph.markIdForUnknownSideEffects(rootId);
+    (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
-function resolveEvalToCode(evalArgument, env, idMap) {
+function resolveEvalToCode(evalArgument, env, idMap, config) {
     const val = evalArgument;
     if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
         const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
@@ -77,13 +79,13 @@ function resolveEvalToCode(evalArgument, env, idMap) {
             return [arg.value.content.str];
         }
         else if (arg.value?.type === type_1.RType.Symbol) {
-            const resolve = (0, resolve_by_name_1.resolveValueOfVariable)(arg.value.content, env, idMap);
-            if (resolve?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
-                return resolve.map(r => r.str);
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap, resolve: config.solver.variables }));
+            if (resolved) {
+                return (0, string_constants_1.collectStrings)(resolved.elements);
             }
         }
         else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(arg.value.functionName.content)) {
-            return handlePaste(arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : ['']);
+            return handlePaste(config, arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : ['']);
         }
         return undefined;
     }
@@ -96,7 +98,7 @@ function resolveEvalToCode(evalArgument, env, idMap) {
         return undefined;
     }
 }
-function getAsString(val, env, idMap) {
+function getAsString(config, val, env, idMap) {
     if (!val) {
         return undefined;
     }
@@ -104,17 +106,17 @@ function getAsString(val, env, idMap) {
         return [val.content.str];
     }
     else if (val.type === type_1.RType.Symbol) {
-        const resolved = (0, resolve_by_name_1.resolveValueOfVariable)(val.content, env, idMap);
-        if (resolved?.every(r => typeof r === 'object' && r !== null && 'str' in r)) {
-            return resolved.map(r => r.str);
+        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap, resolve: config.solver.variables }));
+        if (resolved) {
+            return (0, string_constants_1.collectStrings)(resolved.elements);
         }
     }
     return undefined;
 }
-function handlePaste(args, env, idMap, sepDefault) {
+function handlePaste(config, args, env, idMap, sepDefault) {
     const sepArg = args.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'sep');
     if (sepArg) {
-        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(sepArg.value, env, idMap) : undefined;
+        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(config, sepArg.value, env, idMap) : undefined;
         if (!res) {
             // sep not resolvable clearly / unknown
             return undefined;
@@ -123,7 +125,7 @@ function handlePaste(args, env, idMap, sepDefault) {
     }
     const allArgs = args
         .filter(v => v !== r_function_call_1.EmptyArgument && v.name?.content !== 'sep' && v.value)
-        .map(v => getAsString(v.value, env, idMap));
+        .map(v => getAsString(config, v.value, env, idMap));
     if (allArgs.some(assert_1.isUndefined)) {
         return undefined;
     }

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

@@ -18,6 +18,7 @@ const built_in_1 = require("../../../../../environments/built-in");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const logger_1 = require("../../../../../logger");
 const log_1 = require("../../../../../../util/log");
+const remove_1 = require("../../../../../environments/remove");
 const dotDotDotAccess = /^\.\.\d+$/;
 function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
     const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
@@ -53,7 +54,7 @@ function processNextExpression(currentElement, environment, listEnvironments, re
         linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
     }
 }
-function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextGraph) {
+function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextGraph, localDefs) {
     for (const { functionCall, called } of calledEnvs) {
         const callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
         for (const calledFn of called) {
@@ -79,6 +80,10 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
             }
             if (hasUpdate) {
                 // we update all definitions to be linked with the corresponding function call
+                // we, however, have to ignore expression-local writes!
+                if (localDefs.length > 0) {
+                    environment = (0, remove_1.removeAll)(localDefs, environment);
+                }
                 inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment, callDependencies);
             }
         }
@@ -124,7 +129,7 @@ function processExpressionList(name, args, rootId, data) {
         environment = exitPoints.length > 0 ? (0, overwrite_1.overwriteEnvironment)(environment, processed.environment) : processed.environment;
         const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, processed.graph);
         // if the called function has global redefinitions, we have to keep them within our environment
-        environment = updateSideEffectsForCalledFunctions(calledEnvs, environment, nextGraph);
+        environment = updateSideEffectsForCalledFunctions(calledEnvs, environment, nextGraph, processed.out);
         for (const { nodeId } of processed.out) {
             listEnvironments.add(nodeId);
         }

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

@@ -35,7 +35,7 @@ function processForLoop(name, args, rootId, data) {
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = [...variable.unknownReferences, ...variable.in];
     for (const write of writtenVariable) {
-        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments);
+        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.flowrConfig);
     }
     data = { ...data, environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
@@ -60,8 +60,7 @@ function processForLoop(name, args, rootId, data) {
     });
     /* mark the last argument as nse */
     nextGraph.addEdge(rootId, body.entryPoint, edge_1.EdgeType.NonStandardEvaluation);
-    // as the for-loop always evaluates its variable and condition
-    nextGraph.addEdge(name.info.id, variable.entryPoint, edge_1.EdgeType.Reads);
+    // as the for-loop always evaluates its condition
     nextGraph.addEdge(name.info.id, vector.entryPoint, edge_1.EdgeType.Reads);
     return {
         unknownReferences: [],

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

@@ -7,11 +7,12 @@ const known_call_handling_1 = require("../known-call-handling");
 const common_1 = require("../common");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const logger_1 = require("../../../../../logger");
-const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const edge_1 = require("../../../../../graph/edge");
 const append_1 = require("../../../../../environments/append");
 const identifier_1 = require("../../../../../environments/identifier");
 const environment_1 = require("../../../../../environments/environment");
+const general_1 = require("../../../../../eval/values/general");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 function processIfThenElse(name, args, rootId, data) {
     if (args.length !== 2 && args.length !== 3) {
         logger_1.dataflowLogger.warn(`If-then-else ${name.content} has something different from 2 or 3 arguments, skipping`);
@@ -33,9 +34,9 @@ function processIfThenElse(name, args, rootId, data) {
     let then;
     let makeThenMaybe = false;
     // we should defer this to the abstract interpretation
-    const values = (0, resolve_by_name_1.resolveValueOfVariable)(condArg?.lexeme, data.environment, data.completeAst.idMap);
-    const conditionIsAlwaysFalse = values?.every(d => d === false) ?? false;
-    const conditionIsAlwaysTrue = values?.every(d => d === true) ?? false;
+    const values = (0, alias_tracking_1.resolveIdToValue)(condArg?.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables });
+    const conditionIsAlwaysFalse = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === false) ?? false;
+    const conditionIsAlwaysTrue = (0, general_1.valueSetGuard)(values)?.elements.every(d => d.type === 'logical' && d.value === true) ?? false;
     if (!conditionIsAlwaysFalse) {
         then = (0, processor_1.processDataflowFor)(thenArg, data);
         if (then.entryPoint) {

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

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

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

@@ -12,11 +12,11 @@ const graph_1 = require("../../../../../graph/graph");
 const edge_1 = require("../../../../../graph/edge");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const containers_1 = require("../../../../../../util/containers");
-const config_1 = require("../../../../../../config");
 const unpack_argument_1 = require("../argument/unpack-argument");
 const built_in_access_1 = require("./built-in-access");
 const built_in_1 = require("../../../../../environments/built-in");
 const identifier_1 = require("../../../../../environments/identifier");
+const unknown_replacement_1 = require("../../../../../graph/unknown-replacement");
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -27,7 +27,7 @@ args, rootId, data, config) {
     /* we only get here if <-, <<-, ... or whatever is part of the replacement is not overwritten */
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${name.content} with ${JSON.stringify(args)}, processing`);
     let indices = config.activeIndices;
-    if ((0, config_1.getConfig)().solver.pointerTracking) {
+    if (data.flowrConfig.solver.pointerTracking) {
         indices ??= constructAccessedIndices(name.content, args);
     }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
@@ -60,9 +60,15 @@ args, rootId, data, config) {
         origin: 'builtin:replacement',
         link: config.assignRootId ? { origin: [config.assignRootId] } : undefined
     });
-    const firstArg = (0, unpack_argument_1.unpackArgument)(args[0])?.info.id;
+    const firstArg = (0, unpack_argument_1.unpackArgument)(args[0]);
+    (0, unknown_replacement_1.handleReplacementOperator)({
+        operator: name.content,
+        target: firstArg?.lexeme,
+        env: res.environment,
+        id: rootId
+    });
     if (firstArg) {
-        res.graph.addEdge(firstArg, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
+        res.graph.addEdge(firstArg.info.id, rootId, edge_1.EdgeType.DefinedBy | edge_1.EdgeType.Reads);
     }
     /* a replacement reads all of its call args as well, at least as far as I am aware of */
     for (const arg of callArgs) {
@@ -72,7 +78,7 @@ args, rootId, data, config) {
         }
     }
     const fa = (0, unpack_argument_1.unpackArgument)(args[0]);
-    if (!(0, config_1.getConfig)().solver.pointerTracking && fa) {
+    if (!data.flowrConfig.solver.pointerTracking && fa) {
         res = {
             ...res,
             in: [...res.in, { name: fa.lexeme, type: identifier_1.ReferenceType.Variable, nodeId: fa.info.id, controlDependencies: data.controlDependencies }]

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

@@ -1,5 +1,6 @@
 import { type DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
+import type { FlowrLaxSourcingOptions } from '../../../../../../config';
 import { InferWorkingDirectory } from '../../../../../../config';
 import type { RParseRequest, RParseRequestProvider } from '../../../../../../r-bridge/retriever';
 import type { IdGenerator, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -11,10 +12,11 @@ export declare function setSourceProvider(provider: RParseRequestProvider): void
 export declare function inferWdFromScript(option: InferWorkingDirectory, referenceChain: readonly RParseRequest[]): string[];
 /**
  * Tries to find sourced by a source request and returns the first path that exists
- * @param seed - the path originally requested in the `source` call
- * @param data - more information on the loading context
+ * @param resolveSource - options for lax file sourcing
+ * @param seed          - the path originally requested in the `source` call
+ * @param data          - more information on the loading context
  */
-export declare function findSource(seed: string, data: {
+export declare function findSource(resolveSource: FlowrLaxSourcingOptions | undefined, seed: string, data: {
     referenceChain: readonly RParseRequest[];
 }): string[] | undefined;
 export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {

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

@@ -23,9 +23,12 @@ 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 resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
 const assert_1 = require("../../../../../../util/assert");
 const path_1 = __importDefault(require("path"));
+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 setSourceProvider(provider) {
     sourceProvider = provider;
@@ -65,18 +68,18 @@ function applyReplacements(path, replacements) {
 }
 /**
  * Tries to find sourced by a source request and returns the first path that exists
- * @param seed - the path originally requested in the `source` call
- * @param data - more information on the loading context
+ * @param resolveSource - options for lax file sourcing
+ * @param seed          - the path originally requested in the `source` call
+ * @param data          - more information on the loading context
  */
-function findSource(seed, data) {
-    const config = (0, config_1.getConfig)().solver.resolveSource;
-    const capitalization = config?.ignoreCapitalization ?? false;
+function findSource(resolveSource, seed, data) {
+    const capitalization = resolveSource?.ignoreCapitalization ?? false;
     const explorePaths = [
-        ...(config?.searchPath ?? []),
-        ...(inferWdFromScript(config?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
+        ...(resolveSource?.searchPath ?? []),
+        ...(inferWdFromScript(resolveSource?.inferWorkingDirectory ?? config_1.InferWorkingDirectory.No, data.referenceChain))
     ];
     let tryPaths = [seed];
-    switch (config?.dropPaths ?? config_1.DropPathsOption.No) {
+    switch (resolveSource?.dropPaths ?? config_1.DropPathsOption.No) {
         case config_1.DropPathsOption.Once: {
             const first = platformBasename(seed);
             tryPaths.push(first);
@@ -98,8 +101,8 @@ function findSource(seed, data) {
         case config_1.DropPathsOption.No:
             break;
     }
-    if (config?.applyReplacements) {
-        const r = config.applyReplacements;
+    if (resolveSource?.applyReplacements) {
+        const r = resolveSource.applyReplacements;
         tryPaths = tryPaths.flatMap(t => applyReplacements(t, r));
     }
     const found = [];
@@ -126,9 +129,9 @@ 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 && (0, config_1.getConfig)().ignoreSourceCalls) {
+    if (!config.forceFollow && data.flowrConfig.ignoreSourceCalls) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping source call ${JSON.stringify(sourceFileArgument)} (disabled in config file)`);
-        information.graph.markIdForUnknownSideEffects(rootId);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
     let sourceFile;
@@ -136,36 +139,30 @@ function processSourceCall(name, args, rootId, data, config) {
         sourceFile = [(0, retriever_1.removeRQuotes)(sourceFileArgument.lexeme)];
     }
     else if (sourceFileArgument !== r_function_call_1.EmptyArgument) {
-        sourceFile = (0, resolve_by_name_1.resolveValueOfVariable)(sourceFileArgument.value?.lexeme, data.environment, data.completeAst.idMap)?.map(x => {
-            if (typeof x === 'object' && x && 'str' in x) {
-                return x.str;
-            }
-            else {
-                return undefined;
-            }
-        }).filter(assert_1.isNotUndefined);
+        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 }));
+        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(path, data) : path;
+        let filepath = path ? findSource(data.flowrConfig.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 = (0, config_1.getConfig)().solver.resolveSource?.repeatedSourceLimit ?? 0;
+            const limit = data.flowrConfig.solver.resolveSource?.repeatedSourceLimit ?? 0;
             const findCount = data.referenceChain.filter(e => e.request === request.request && e.content === request.content).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`);
-                information.graph.markIdForUnknownSideEffects(rootId);
+                (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));
         }
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
-    information.graph.markIdForUnknownSideEffects(rootId);
+    (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
 function sourceRequest(rootId, request, data, information, getId) {
@@ -173,7 +170,7 @@ function sourceRequest(rootId, request, data, information, getId) {
         /* check if the file exists and if not, fail */
         if (!fs_1.default.existsSync(request.content)) {
             logger_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}: file does not exist`);
-            information.graph.markIdForUnknownSideEffects(rootId);
+            (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
             return information;
         }
     }
@@ -184,7 +181,7 @@ function sourceRequest(rootId, request, data, information, getId) {
         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, file) : (0, parser_1.normalize)({ parsed }, getId, file));
+            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, data.flowrConfig, file) : (0, parser_1.normalize)({ parsed }, getId, file));
         dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
             ...data,
             currentRequest: request,
@@ -195,7 +192,7 @@ function sourceRequest(rootId, request, data, information, getId) {
     catch (e) {
         logger_1.dataflowLogger.error(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
         logger_1.dataflowLogger.error(e.stack);
-        information.graph.markIdForUnknownSideEffects(rootId);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, 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
@@ -229,7 +226,7 @@ function standaloneSourceFile(inputRequest, data, uniqueSourceId, 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`);
-        information.graph.markIdForUnknownSideEffects(uniqueSourceId);
+        (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, uniqueSourceId);
         return information;
     }
     return sourceRequest(uniqueSourceId, request, {

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 (!(0, config_1.getConfig)().solver.pointerTracking) {
+    if (!data.flowrConfig.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)(vectorArgs.length)) {
+    if ((0, config_1.isOverPointerAnalysisThreshold)(data.flowrConfig, vectorArgs.length)) {
         return fnCall.information;
     }
     const indices = {