@eagleoutice/flowr 2.2.15 → 2.2.16

package/dataflow/environments/built-in.d.ts

@@ -32,6 +32,7 @@ import type { REnvironmentInformation } from './environment';
 import type { Value } from '../eval/values/r-value';
 import { resolveAsVector } from '../eval/resolve/resolve';
 import type { DataflowGraph } from '../graph/graph';
+import type { VariableResolve } from '../../config';
 export type BuiltIn = `built-in:${string}`;
 export declare function builtInId(name: string): BuiltIn;
 export declare function isBuiltIn(name: NodeId | string): name is BuiltIn;
@@ -48,6 +49,7 @@ export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierRefere
     definedAt: BuiltIn;
     value: T;
 }
+export type UseAsProcessors = 'builtin:default' | 'builtin:return' | 'builtin:stop';
 export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly returnsNthArgument?: number | 'last';
     readonly cfg?: ExitPointType;
@@ -55,8 +57,12 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
     readonly hasUnknownSideEffects?: boolean | LinkTo<RegExp | string>;
     /** record mapping the actual function name called to the arguments that should be treated as function calls */
     readonly treatAsFnCall?: Record<string, readonly string[]>;
+    /** Name that should be used for the origin (useful when needing to differentiate between
+     * functions like 'return' that use the default builtin processor)
+     */
+    readonly useAsProcessor?: UseAsProcessors;
 }
-export type BuiltInEvalHandler = (a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
+export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 export declare function registerBuiltInFunctions<Config extends object, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare const BuiltInProcessorMapper: {

package/dataflow/environments/built-in.js

@@ -42,7 +42,7 @@ function isBuiltIn(name) {
     return String(name).startsWith('built-in:');
 }
 function defaultBuiltInProcessor(name, args, rootId, data, config) {
-    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:default' });
+    const { information: res, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs, origin: config.useAsProcessor ?? 'builtin:default' });
     if (config.returnsNthArgument !== undefined) {
         const arg = config.returnsNthArgument === 'last' ? processedArguments[args.length - 1] : processedArguments[config.returnsNthArgument];
         if (arg !== undefined) {
@@ -90,7 +90,7 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
                     environment: data.environment,
                     onlyBuiltin: false,
                     cds: data.controlDependencies,
-                    origin: ['builtin:default']
+                    origin: [config.useAsProcessor ?? 'builtin:default']
                 });
             }
         }

package/dataflow/environments/default-builtin-config.js

@@ -102,7 +102,7 @@ exports.DefaultBuiltinConfig = [
             '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':',
             'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max',
             'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean',
-            'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
+            'unique', 'paste', 'paste0', 'read.csv', 'is.null', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
             'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor',
             'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar',
             'pdf', 'jpeg', 'png', 'windows', 'postscript', 'xfig', 'bitmap', 'pictex', 'cairo_pdf', 'svg', 'bmp', 'tiff', 'X11', 'quartz',
@@ -215,7 +215,9 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['eval'], processor: 'builtin:eval', config: { includeFunctionCall: true }, assumePrimitive: true },
     { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
-    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ }, assumePrimitive: false },
+    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: false },
+    { type: 'function', names: ['stop'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop' }, assumePrimitive: false },
+    { type: 'function', names: ['stopifnot'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stopifnot' }, assumePrimitive: false },
     { type: 'function', names: ['break'], processor: 'builtin:default', config: { cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
     { type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
     { type: 'function', names: ['{'], processor: 'builtin:expression-list', config: {}, assumePrimitive: true },

package/dataflow/environments/define.d.ts

@@ -1,5 +1,6 @@
 import type { REnvironmentInformation } from './environment';
 import type { IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
+import type { FlowrConfigOptions } from '../../config';
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
@@ -8,4 +9,4 @@ export declare function mergeDefinitions(existing: readonly IdentifierDefinition
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.
  */
-export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation): REnvironmentInformation;
+export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -6,12 +6,11 @@ const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
-const config_1 = require("../../config");
-function defInEnv(newEnvironments, name, definition) {
+function defInEnv(newEnvironments, name, definition, config) {
     const existing = newEnvironments.memory.get(name);
     // When there are defined indices, merge the definitions
     const inGraphDefinition = definition;
-    if ((0, config_1.getConfig)().solver.pointerTracking &&
+    if (config.solver.pointerTracking &&
         existing !== undefined &&
         inGraphDefinition.controlDependencies === undefined) {
         if (inGraphDefinition.indicesCollection !== undefined) {
@@ -122,7 +121,7 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.
  */
-function define(definition, superAssign, environment) {
+function define(definition, superAssign, environment, config) {
     const name = definition.name;
     (0, assert_1.guard)(name !== undefined, () => `Name must be defined, but isn't for ${JSON.stringify(definition)}`);
     let newEnvironment;
@@ -147,7 +146,7 @@ function define(definition, superAssign, environment) {
     }
     else {
         newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, false);
-        defInEnv(newEnvironment.current, name, definition);
+        defInEnv(newEnvironment.current, name, definition, config);
     }
     return newEnvironment;
 }

package/dataflow/environments/remove.d.ts

@@ -1,6 +1,12 @@
 import type { REnvironmentInformation } from './environment';
 import type { Identifier } from './identifier';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Removes all definitions of a given name from the environment.
  */
 export declare function remove(name: Identifier, environment: REnvironmentInformation): REnvironmentInformation;
+/** Creates a copy of the original environment but without the definitions of the given ids */
+export declare function removeAll(definitions: readonly {
+    nodeId: NodeId;
+    name: Identifier | undefined;
+}[], environment: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/remove.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remove = remove;
+exports.removeAll = removeAll;
 const environment_1 = require("./environment");
 const info_1 = require("../info");
+const clone_1 = require("./clone");
 /**
  * Removes all definitions of a given name from the environment.
  */
@@ -21,4 +23,31 @@ function remove(name, environment) {
     // we never remove built ins
     return environment;
 }
+/** Creates a copy of the original environment but without the definitions of the given ids */
+function removeAll(definitions, environment) {
+    environment = (0, clone_1.cloneEnvironmentInformation)(environment, true);
+    let current = environment.current;
+    do {
+        for (const { nodeId, name } of definitions) {
+            if (name) {
+                current.memory.delete(name);
+            }
+            else {
+                // remove all definitions for the node id
+                for (const [key, values] of current.memory) {
+                    const res = values.filter(v => v.nodeId === nodeId);
+                    if (res.length > 0) {
+                        current.memory.set(key, values);
+                    }
+                    else {
+                        current.memory.delete(key);
+                    }
+                }
+            }
+        }
+        current = current.parent;
+    } while (current.id !== environment_1.BuiltInEnvironment.id);
+    // we never remove built ins so we can stop one early
+    return environment;
+}
 //# sourceMappingURL=remove.js.map

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -1,3 +1,4 @@
+import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../environments/environment';
@@ -14,6 +15,8 @@ export interface ResolveInfo {
     graph?: DataflowGraph;
     /** Whether to track variables */
     full?: boolean;
+    /** Variable resolve mode */
+    resolve: VariableResolve;
 }
 /**
  * Gets the definitions / aliases of a node
@@ -48,8 +51,9 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @param graph       - The graph to resolve in
  * @param idMap       - The id map to resolve the node if given as an id
  * @param full        - Whether to track aliases on resolve
+ * @param resolve     - Variable resolve mode
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *
@@ -57,13 +61,14 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  * {@link getAliases} function) to resolve a node to a value.
  *
  *
+ * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
  * @param graph      - Dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-export declare function trackAliasInEnvironments(identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+export declare function trackAliasInEnvironments(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

package/dataflow/eval/resolve/alias-tracking.js

@@ -115,8 +115,9 @@ function getAliases(sourceIds, dataflow, environment) {
  * @param graph       - The graph to resolve in
  * @param idMap       - The id map to resolve the node if given as an id
  * @param full        - Whether to track aliases on resolve
+ * @param resolve     - Variable resolve mode
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
+function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve }) {
     if (id === undefined) {
         return r_value_1.Top;
     }
@@ -129,16 +130,16 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
         case type_1.RType.Argument:
         case type_1.RType.Symbol:
             if (environment) {
-                return full ? trackAliasInEnvironments(node.lexeme, environment, graph, idMap) : r_value_1.Top;
+                return full ? trackAliasInEnvironments(resolve, node.lexeme, environment, graph, idMap) : r_value_1.Top;
             }
-            else if (graph && (0, config_1.getConfig)().solver.variables === config_1.VariableResolve.Alias) {
+            else if (graph && resolve === config_1.VariableResolve.Alias) {
                 return full ? trackAliasesInGraph(node.info.id, graph, idMap) : r_value_1.Top;
             }
             else {
                 return r_value_1.Top;
             }
         case type_1.RType.FunctionCall:
-            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(node, environment, graph, idMap));
+            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(resolve, node, environment, graph, idMap));
         case type_1.RType.String:
         case type_1.RType.Number:
         case type_1.RType.Logical:
@@ -154,13 +155,14 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true }) {
  * {@link getAliases} function) to resolve a node to a value.
  *
  *
+ * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
  * @param graph      - Dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-function trackAliasInEnvironments(identifier, use, graph, idMap) {
+function trackAliasInEnvironments(resolve, identifier, use, graph, idMap) {
     if (identifier === undefined) {
         return r_value_1.Top;
     }
@@ -184,7 +186,7 @@ function trackAliasInEnvironments(identifier, use, graph, idMap) {
             for (const alias of def.value) {
                 const definitionOfAlias = idMap?.get(alias);
                 if (definitionOfAlias !== undefined) {
-                    const value = (0, resolve_1.resolveNode)(definitionOfAlias, use, graph, idMap);
+                    const value = (0, resolve_1.resolveNode)(resolve, definitionOfAlias, use, graph, idMap);
                     if ((0, r_value_1.isTop)(value)) {
                         return r_value_1.Top;
                     }
@@ -198,6 +200,7 @@ function trackAliasInEnvironments(identifier, use, graph, idMap) {
     }
     return (0, set_constants_1.setFrom)(...values);
 }
+/** given an unknown alias, we have to clear all values in the environments */
 (0, unknown_side_effect_1.onUnknownSideEffect)((_graph, env, _id, target) => {
     if (target) {
         return;

package/dataflow/eval/resolve/resolve-argument.d.ts

@@ -0,0 +1,8 @@
+import type { DataflowGraph } from '../../graph/graph';
+import type { DataflowGraphVertexFunctionCall } from '../../graph/vertex';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { VariableResolve } from '../../../config';
+/**
+ * Get the values of all arguments matching the criteria.
+ */
+export declare function getArgumentStringValue(variableResolve: VariableResolve, graph: DataflowGraph, vertex: DataflowGraphVertexFunctionCall, argumentIndex: number | 'unnamed' | undefined, argumentName: string | undefined, resolveValue: boolean | 'library' | undefined): Map<NodeId, Set<string | undefined>> | undefined;

package/dataflow/eval/resolve/resolve-argument.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgumentStringValue = getArgumentStringValue;
+const graph_1 = require("../../graph/graph");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const assert_1 = require("../../../util/assert");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const dependencies_query_format_1 = require("../../../queries/catalog/dependencies-query/dependencies-query-format");
+const general_1 = require("../values/general");
+const alias_tracking_1 = require("./alias-tracking");
+const r_value_1 = require("../values/r-value");
+const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
+const string_constants_1 = require("../values/string/string-constants");
+/**
+ * Get the values of all arguments matching the criteria.
+ */
+function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, argumentName, resolveValue) {
+    if (argumentName) {
+        const arg = vertex?.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argumentName);
+        if (arg >= 0) {
+            argumentIndex = arg;
+        }
+    }
+    if (!vertex || argumentIndex === undefined) {
+        return undefined;
+    }
+    if (argumentIndex === 'unnamed') {
+        // return all unnamed arguments
+        const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument).filter(assert_1.isNotUndefined);
+        const map = new Map();
+        for (const ref of references) {
+            let valueNode = graph.idMap?.get(ref);
+            if (valueNode?.type === type_1.RType.Argument) {
+                valueNode = valueNode.value;
+            }
+            if (valueNode) {
+                // this should be evaluated in the callee-context
+                const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
+                map.set(ref, new Set(values));
+            }
+        }
+        return map;
+    }
+    if (argumentIndex < vertex.args.length) {
+        const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
+        if (!arg) {
+            return undefined;
+        }
+        let valueNode = graph.idMap?.get(arg);
+        if (valueNode?.type === type_1.RType.Argument) {
+            valueNode = valueNode.value;
+        }
+        if (valueNode) {
+            const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
+            return new Map([[arg, new Set(values)]]);
+        }
+    }
+    return undefined;
+}
+function hasCharacterOnly(variableResolve, graph, vertex, idMap) {
+    if (!vertex.args || vertex.args.length === 0 || !idMap) {
+        return false;
+    }
+    const treatAsChar = getArgumentStringValue(variableResolve, graph, vertex, 5, 'character.only', true);
+    if (!treatAsChar) {
+        return false;
+    }
+    const hasTrue = [...treatAsChar.values()].some(set => set?.has('TRUE'));
+    const hasFalse = hasTrue ? [...treatAsChar.values()].some(set => set === undefined || set.has('FALSE')) : false;
+    if (hasTrue && hasFalse) {
+        return 'maybe';
+    }
+    else {
+        return hasTrue;
+    }
+}
+function resolveBasedOnConfig(variableResolve, graph, vertex, argument, environment, idMap, resolveValue) {
+    let full = true;
+    if (!resolveValue) {
+        full = false;
+    }
+    if (resolveValue === 'library') {
+        const hasChar = hasCharacterOnly(variableResolve, graph, vertex, idMap);
+        if (hasChar === false) {
+            if (argument.type === type_1.RType.Symbol) {
+                return [argument.lexeme];
+            }
+            full = false;
+        }
+    }
+    const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(argument, { environment, graph, full, resolve: variableResolve }));
+    if (resolved) {
+        const values = [];
+        for (const value of resolved.elements) {
+            if (!(0, r_value_1.isValue)(value)) {
+                return undefined;
+            }
+            else if (value.type === 'string' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.str);
+            }
+            else if (value.type === 'logical' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.valueOf() ? convert_values_1.RTrue : convert_values_1.RFalse);
+            }
+            else if (value.type === 'vector' && (0, r_value_1.isValue)(value.elements)) {
+                const elements = (0, string_constants_1.collectStrings)(value.elements, !full);
+                if (elements === undefined) {
+                    return undefined;
+                }
+                values.push(...elements);
+            }
+            else {
+                return undefined;
+            }
+        }
+        return values;
+    }
+}
+//# sourceMappingURL=resolve-argument.js.map

package/dataflow/eval/resolve/resolve.d.ts

@@ -2,33 +2,36 @@ import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/m
 import type { REnvironmentInformation } from '../../environments/environment';
 import type { DataflowGraph } from '../../graph/graph';
 import type { Value } from '../values/r-value';
+import type { VariableResolve } from '../../../config';
 /**
  * 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
  */
-export declare function resolveNode(a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
 /**
  * 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
+ * This function converts an r-node to a Value Vector {@link vectorFrom}
+ * It also recursively 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}
  *
- * @param a     - Node of the vector to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow graph
- * @param map   - Idmap of Dataflow Graph
+ * @param a       - Node of the vector to resolve
+ * @param env     - Environment to use
+ * @param resolve - Variable resolve mode
+ * @param graph   - Dataflow graph
+ * @param map     - Idmap of Dataflow Graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveAsVector(resolve: VariableResolve, a: RNodeWithParent, env: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;

package/dataflow/eval/resolve/resolve.js

@@ -15,18 +15,19 @@ const vector_constants_1 = require("../values/vectors/vector-constants");
 const alias_tracking_1 = require("./alias-tracking");
 /**
  * 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);
     }
@@ -43,27 +44,28 @@ function resolveNode(a, env, graph, map) {
         }
         if (origin.proc in built_in_1.BuiltInEvalHandlerMapper) {
             const handler = built_in_1.BuiltInEvalHandlerMapper[origin.proc];
-            return handler(a, env, graph, map);
+            return handler(resolve, a, env, graph, map);
         }
     }
     return r_value_1.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
+ * This function converts an r-node to a Value Vector {@link vectorFrom}
+ * It also recursively 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}
  *
- * @param a     - Node of the vector to resolve
- * @param env   - Environment to use
- * @param graph - Dataflow graph
- * @param map   - Idmap of Dataflow Graph
+ * @param a       - Node of the vector to resolve
+ * @param env     - Environment to use
+ * @param resolve - Variable resolve mode
+ * @param graph   - Dataflow graph
+ * @param map     - Idmap of Dataflow Graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(a, env, graph, map) {
+function resolveAsVector(resolve, a, env, graph, map) {
     (0, assert_1.guard)(a.type === type_1.RType.FunctionCall);
     const values = [];
     for (const arg of a.arguments) {
@@ -74,14 +76,14 @@ function resolveAsVector(a, env, graph, map) {
             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 });
+            const value = (0, alias_tracking_1.resolveIdToValue)(arg.info.id, { environment: env, idMap: map, graph: graph, full: true, resolve });
             if ((0, r_value_1.isTop)(value)) {
                 return r_value_1.Top;
             }
             values.push(value);
         }
         else {
-            const val = resolveNode(arg.value, env, graph, map);
+            const val = resolveNode(resolve, arg.value, env, graph, map);
             if ((0, r_value_1.isTop)(val)) {
                 return r_value_1.Top;
             }

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>');