@eagleoutice/flowr 2.2.15 → 2.3.0

package/dataflow/eval/resolve/resolve.js

@@ -2,31 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveNode = resolveNode;
 exports.resolveAsVector = resolveAsVector;
+exports.resolveAsSeq = resolveAsSeq;
+exports.resolveAsPlus = resolveAsPlus;
+exports.resolveAsMinus = resolveAsMinus;
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const assert_1 = require("../../../util/assert");
+const r_value_1 = require("../../../util/r-value");
 const built_in_1 = require("../../environments/built-in");
 const dfg_get_origin_1 = require("../../origin/dfg-get-origin");
 const interval_constants_1 = require("../values/intervals/interval-constants");
 const logical_constants_1 = require("../values/logical/logical-constants");
-const r_value_1 = require("../values/r-value");
+const r_value_2 = require("../values/r-value");
 const string_constants_1 = require("../values/string/string-constants");
 const vector_constants_1 = require("../values/vectors/vector-constants");
 const alias_tracking_1 = require("./alias-tracking");
+const scalar_consatnts_1 = require("../values/scalar/scalar-consatnts");
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
- * you want to resolve the value of a identifier / node
+ * you want to resolve the value of an identifier / node
  *
- * This function converts an RNode to its Value, but also recursivly resolves
+ * This function converts an RNode to its Value, but also recursively resolves
  * aliases and vectors (in case of a vector).
  *
- * @param a     - Ast node to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow Graph to use
- * @param map   - Idmap of Dataflow Graph
+ * @param a       - Ast node to resolve
+ * @param resolve - Variable resolve mode
+ * @param env     - Environment to use
+ * @param graph   - Dataflow Graph to use
+ * @param map     - Idmap of Dataflow Graph
  * @returns resolved value or top/bottom
  */
-function resolveNode(a, env, graph, map) {
+function resolveNode(resolve, a, env, graph, map) {
     if (a.type === type_1.RType.String) {
         return (0, string_constants_1.stringFrom)(a.content.str);
     }
@@ -36,58 +41,149 @@ function resolveNode(a, env, graph, map) {
     else if (a.type === type_1.RType.Logical) {
         return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (a.type === type_1.RType.FunctionCall && env && graph) {
+    else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
-            return r_value_1.Top;
+            return r_value_2.Top;
         }
-        if (origin.proc in built_in_1.BuiltInEvalHandlerMapper) {
-            const handler = built_in_1.BuiltInEvalHandlerMapper[origin.proc];
-            return handler(a, env, graph, map);
+        let builtInName;
+        if ((0, built_in_1.isBuiltIn)(origin.proc)) {
+            builtInName = origin.proc;
+        }
+        else if (a.type === type_1.RType.FunctionCall && a.named) {
+            builtInName = (0, built_in_1.builtInId)(a.functionName.content);
+        }
+        else if (a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) {
+            builtInName = (0, built_in_1.builtInId)(a.operator);
+        }
+        else {
+            return r_value_2.Top;
+        }
+        if (Object.prototype.hasOwnProperty.call(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
+            const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
+            return handler(resolve, a, env, graph, map);
         }
     }
-    return r_value_1.Top;
+    return r_value_2.Top;
 }
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
- * you want to resolve the value of a identifier / node
+ * you want to resolve the value of an identifier / node
  *
- * This function converts an rnode to a Value Vector {@link vectorFrom}
- * It also recursivly resolves any symbols, values, function calls (only c), in
- * order to construct the value of the vector to resolve by calling {@link resolveIdToValue}
- * or {@link resolveNode}
+ * This function resolves a vector function call `c` to a {@link ValueVector}
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
  *
- * @param a     - Node of the vector to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow graph
- * @param map   - Idmap of Dataflow Graph
+ * @param resolve - Variable resolve mode
+ * @param node    - Node of the vector function to resolve
+ * @param env     - Environment to use
+ * @param graph   - Dataflow graph
+ * @param map     - Id map of the dataflow graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(a, env, graph, map) {
-    (0, assert_1.guard)(a.type === type_1.RType.FunctionCall);
-    const values = [];
-    for (const arg of a.arguments) {
-        if (arg === r_function_call_1.EmptyArgument) {
-            continue;
-        }
-        if (arg.value === undefined) {
-            return r_value_1.Top;
-        }
-        if (arg.value.type === type_1.RType.Symbol) {
-            const value = (0, alias_tracking_1.resolveIdToValue)(arg.info.id, { environment: env, idMap: map, graph: graph, full: true });
-            if ((0, r_value_1.isTop)(value)) {
-                return r_value_1.Top;
-            }
-            values.push(value);
-        }
-        else {
-            const val = resolveNode(arg.value, env, graph, map);
-            if ((0, r_value_1.isTop)(val)) {
-                return r_value_1.Top;
-            }
-            values.push(val);
-        }
+function resolveAsVector(resolve, node, environment, graph, idMap) {
+    if (node.type !== type_1.RType.FunctionCall) {
+        return r_value_2.Top;
     }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const values = node.arguments.map(arg => arg !== r_function_call_1.EmptyArgument ? (0, alias_tracking_1.resolveIdToValue)(arg.value, resolveInfo) : r_value_2.Top);
     return (0, vector_constants_1.vectorFrom)((0, vector_constants_1.flattenVectorElements)(values));
 }
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the sequence operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueVector of ValueNumbers or Top
+ */
+function resolveAsSeq(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.BinaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const leftArg = (0, alias_tracking_1.resolveIdToValue)(operator.lhs, resolveInfo);
+    const rightArg = (0, alias_tracking_1.resolveIdToValue)(operator.rhs, resolveInfo);
+    const leftValue = (0, r_value_1.unliftRValue)(leftArg);
+    const rightValue = (0, r_value_1.unliftRValue)(rightArg);
+    if ((0, r_value_1.isRNumberValue)(leftValue) && (0, r_value_1.isRNumberValue)(rightValue)) {
+        return (0, vector_constants_1.vectorFrom)(createNumberSequence(leftValue, rightValue).map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.Top;
+}
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the plus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+function resolveAsPlus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)(argValue);
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(scalar_consatnts_1.liftScalar));
+    }
+    return r_value_2.Top;
+}
+/**
+ * Helper function used by {@link resolveIdToValue}, please use that instead, if
+ * you want to resolve the value of an identifier / node
+ *
+ * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
+ * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
+ *
+ * @param resolve  - Variable resolve mode
+ * @param operator - Node of the minus operator to resolve
+ * @param env      - Environment to use
+ * @param graph    - Dataflow graph
+ * @param map      - Id map of the dataflow graph
+ * @returns ValueNumber, ValueVector of ValueNumbers, or Top
+ */
+function resolveAsMinus(resolve, operator, environment, graph, idMap) {
+    if (operator.type !== type_1.RType.UnaryOp) {
+        return r_value_2.Top;
+    }
+    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
+    const argValue = (0, r_value_1.unliftRValue)(arg);
+    if ((0, r_value_1.isRNumberValue)(argValue)) {
+        return (0, scalar_consatnts_1.liftScalar)({ ...argValue, num: -argValue.num });
+    }
+    else if (Array.isArray(argValue) && argValue.every(r_value_1.isRNumberValue)) {
+        return (0, vector_constants_1.vectorFrom)(argValue.map(element => (0, scalar_consatnts_1.liftScalar)({ ...element, num: -element.num })));
+    }
+    return r_value_2.Top;
+}
+function createNumberSequence(start, end) {
+    const sequence = [];
+    const min = Math.min(start.num, end.num);
+    const max = Math.max(start.num, end.num);
+    for (let i = min; i <= max; i++) {
+        sequence.push({ ...start, num: i });
+    }
+    if (start > end) {
+        sequence.reverse();
+    }
+    return sequence;
+}
 //# sourceMappingURL=resolve.js.map

package/dataflow/eval/values/string/string-constants.d.ts

@@ -2,7 +2,7 @@ import type { RStringValue } from '../../../../r-bridge/lang-4.x/convert-values'
 import type { Lift, Value, ValueString } from '../r-value';
 export declare function stringFrom(str: RStringValue | string): ValueString;
 export declare function liftString(str: Lift<RStringValue>): ValueString;
-export declare function collectStrings(a: Value[]): string[] | undefined;
+export declare function collectStrings(a: Value[], withQuotes?: boolean): string[] | undefined;
 export declare const ValueEmptyString: ValueString<Lift<RStringValue>>;
 export declare const ValueStringTop: ValueString<Lift<RStringValue>>;
 export declare const ValueStringBot: ValueString<Lift<RStringValue>>;

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

@@ -21,7 +21,7 @@ function liftString(str) {
         value: str
     };
 }
-function collectStrings(a) {
+function collectStrings(a, withQuotes = false) {
     if ((0, general_1.bottomTopGuard)(a)) {
         return undefined;
     }
@@ -30,7 +30,12 @@ function collectStrings(a) {
         if (value.type !== 'string' || !(0, r_value_1.isValue)(value) || !(0, r_value_1.isValue)(value.value)) {
             return undefined;
         }
-        values.push(value.value.str);
+        if (withQuotes) {
+            values.push(`${value.value.quotes}${value.value.str}${value.value.quotes}`);
+        }
+        else {
+            values.push(value.value.str);
+        }
     }
     return values;
 }

package/dataflow/extractor.d.ts

@@ -3,6 +3,7 @@ import type { DataflowProcessors } from './processor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RParseRequests } from '../r-bridge/retriever';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
+import type { FlowrConfigOptions } from '../config';
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -14,4 +15,4 @@ export declare const processors: DataflowProcessors<ParentInformation>;
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function produceDataFlowGraph<OtherInfo>(parser: Parser<KnownParserType>, request: RParseRequests, completeAst: NormalizedAst<OtherInfo & ParentInformation>, config: FlowrConfigOptions): DataflowInformation;

package/dataflow/extractor.js

@@ -80,7 +80,7 @@ function resolveLinkToSideEffects(ast, graph) {
  * (e.g., in the event of a `source` call).
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
-function produceDataFlowGraph(parser, request, completeAst) {
+function produceDataFlowGraph(parser, request, completeAst, config) {
     let firstRequest;
     const multifile = Array.isArray(request);
     if (multifile) {
@@ -97,6 +97,7 @@ function produceDataFlowGraph(parser, request, completeAst) {
         currentRequest: firstRequest,
         controlDependencies: undefined,
         referenceChain: [firstRequest],
+        flowrConfig: config
     };
     let df = (0, processor_1.processDataflowFor)(completeAst.ast, dfData);
     df.graph.sourced.unshift(firstRequest.request === 'file' ? firstRequest.content : '<inline>');

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

@@ -13,7 +13,6 @@ const built_in_assignment_1 = require("./built-in-assignment");
 const identifier_1 = require("../../../../../environments/identifier");
 const vertex_1 = require("../../../../../graph/vertex");
 const containers_1 = require("../../../../../../util/containers");
-const config_1 = require("../../../../../../config");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'table:assign' }).information;
@@ -30,8 +29,8 @@ function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
  * ```
  */
 function processAccess(name, args, rootId, data, config) {
-    if (args.length < 2) {
-        logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
+    if (args.length < 1) {
+        logger_1.dataflowLogger.warn(`Access ${name.content} has less than 1 argument, skipping`);
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'default' }).information;
     }
     const head = args[0];
@@ -113,9 +112,9 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
         data.environment.current.memory.set(':=', existing);
     }
     if (head.value && outInfo.definitionRootNodes.length > 0) {
-        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
+        (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data.flowrConfig);
     }
-    if ((0, config_1.getConfig)().solver.pointerTracking) {
+    if (data.flowrConfig.solver.pointerTracking) {
         referenceAccessedIndices(args, data, fnCall, rootId, true);
     }
     return fnCall;
@@ -157,7 +156,7 @@ function processStringBasedAccess(args, data, name, rootId, config) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs,
         origin: 'builtin:access'
     });
-    if ((0, config_1.getConfig)().solver.pointerTracking) {
+    if (data.flowrConfig.solver.pointerTracking) {
         referenceAccessedIndices(newArgs, data, fnCall, rootId, false);
     }
     return fnCall;

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

@@ -57,7 +57,7 @@ function processApply(name, args, rootId, data, config) {
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
         if (resolveValue) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap }));
+            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;
             }

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,7 +17,6 @@ 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");
@@ -216,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.
@@ -235,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);
         }
@@ -282,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");
@@ -31,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)`);
         (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 = {
@@ -68,7 +67,7 @@ function processEvalCall(name, args, rootId, data, config) {
     (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');
@@ -80,13 +79,13 @@ function resolveEvalToCode(evalArgument, env, idMap) {
             return [arg.value.content.str];
         }
         else if (arg.value?.type === type_1.RType.Symbol) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap }));
+            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;
     }
@@ -99,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;
     }
@@ -107,17 +106,17 @@ function getAsString(val, env, idMap) {
         return [val.content.str];
     }
     else if (val.type === type_1.RType.Symbol) {
-        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap }));
+        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;
@@ -126,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

@@ -34,7 +34,7 @@ function processIfThenElse(name, args, rootId, data) {
     let then;
     let makeThenMaybe = false;
     // we should defer this to the abstract interpretation
-    const values = (0, alias_tracking_1.resolveIdToValue)(condArg?.info.id, { environment: data.environment, idMap: data.completeAst.idMap });
+    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) {

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,7 +12,6 @@ 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");
@@ -28,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 */
@@ -79,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 }]