@eagleoutice/flowr 2.6.3 → 2.7.2

package/dataflow/environments/reference-to-maybe.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeReferenceMaybe = makeReferenceMaybe;
+exports.makeAllMaybe = makeAllMaybe;
+const identifier_1 = require("./identifier");
+const resolve_by_name_1 = require("./resolve-by-name");
+/**
+ * Marks the reference as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ */
+function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
+    if (includeDefs) {
+        const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments, ref.type) : undefined;
+        for (const definition of definitions ?? []) {
+            if (definition.type !== identifier_1.ReferenceType.BuiltInFunction && definition.type !== identifier_1.ReferenceType.BuiltInConstant) {
+                if (definition.controlDependencies) {
+                    if (defaultCd && !definition.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
+                        definition.controlDependencies.push(defaultCd);
+                    }
+                }
+                else {
+                    definition.controlDependencies = defaultCd ? [defaultCd] : [];
+                }
+            }
+        }
+    }
+    const node = graph.getVertex(ref.nodeId, true);
+    if (node) {
+        if (node.cds) {
+            if (defaultCd && !node.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
+                node.cds.push(defaultCd);
+            }
+        }
+        else {
+            node.cds = defaultCd ? [defaultCd] : [];
+        }
+    }
+    if (ref.controlDependencies) {
+        if (defaultCd && !ref.controlDependencies.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
+            return { ...ref, controlDependencies: (ref.controlDependencies ?? []).concat(defaultCd ? [defaultCd] : []) };
+        }
+    }
+    else {
+        return { ...ref, controlDependencies: ref.controlDependencies ?? (defaultCd ? [defaultCd] : []) };
+    }
+    return ref;
+}
+/**
+ * Marks all references as maybe (i.e., as controlled by a set of {@link IdentifierReference#controlDependencies|control dependencies}).
+ * @see {@link makeReferenceMaybe}
+ */
+function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
+    return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
+}
+//# sourceMappingURL=reference-to-maybe.js.map

package/dataflow/environments/resolve-by-name.d.ts

@@ -3,13 +3,18 @@ import { Ternary } from '../../util/logic';
 import { type Identifier, type IdentifierDefinition, ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
-export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
+export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target: ReferenceType): IdentifierDefinition[] | undefined;
+/**
+ * The more performant version of {@link resolveByName} when the target type is unknown.
+ */
+export declare function resolveByNameAnyType(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
 /**
  *
  */

package/dataflow/environments/resolve-by-name.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveByName = resolveByName;
+exports.resolveByNameAnyType = resolveByNameAnyType;
 exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 const logic_1 = require("../../util/logic");
 const identifier_1 = require("./identifier");
@@ -22,26 +23,34 @@ const TargetTypePredicate = {
 };
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
+ * If the type you want to reference is unknown, please use {@link resolveByNameAnyType} instead.
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
-function resolveByName(name, environment, target = identifier_1.ReferenceType.Unknown) {
+function resolveByName(name, environment, target) {
+    if (target === identifier_1.ReferenceType.Unknown) {
+        return resolveByNameAnyType(name, environment);
+    }
     let current = environment.current;
     let definitions = undefined;
     const wantedType = TargetTypePredicate[target];
     do {
         const definition = current.memory.get(name);
         if (definition !== undefined) {
-            const filtered = target === identifier_1.ReferenceType.Unknown ? definition : definition.filter(wantedType);
+            const filtered = definition.filter(wantedType);
             if (filtered.length === definition.length && definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
                 return definition;
             }
             else if (filtered.length > 0) {
-                definitions ??= [];
-                definitions = definitions.concat(filtered);
+                if (definitions) {
+                    definitions = definitions.concat(filtered);
+                }
+                else {
+                    definitions = filtered;
+                }
             }
         }
         current = current.parent;
@@ -54,6 +63,49 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
         return builtIns;
     }
 }
+/**
+ * The more performant version of {@link resolveByName} when the target type is unknown.
+ */
+function resolveByNameAnyType(name, environment) {
+    let current = environment.current;
+    const g = current.cache?.get(name);
+    if (g !== undefined) {
+        return g;
+    }
+    let definitions = undefined;
+    do {
+        const definition = current.memory.get(name);
+        if (definition) {
+            if (definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+                environment.current.cache ??= new Map();
+                environment.current.cache?.set(name, definition);
+                return definition;
+            }
+            else if (definition.length > 0) {
+                if (definitions) {
+                    definitions = definitions.concat(definition);
+                }
+                else {
+                    definitions = definition;
+                }
+            }
+        }
+        current = current.parent;
+    } while (!current.builtInEnv);
+    const builtIns = current.memory.get(name);
+    let ret;
+    if (definitions) {
+        ret = builtIns === undefined ? definitions : definitions.concat(builtIns);
+    }
+    else {
+        ret = builtIns;
+    }
+    if (ret) {
+        environment.current.cache ??= new Map();
+        environment.current.cache?.set(name, ret);
+    }
+    return ret;
+}
 /**
  *
  */

package/dataflow/environments/scoping.d.ts

@@ -3,9 +3,9 @@ import { type REnvironmentInformation } from './environment';
  * Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link popLocalEnvironment} - to remove the local scope again
  */
-export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+export declare function pushLocalEnvironment({ level, current }: REnvironmentInformation): REnvironmentInformation;
 /**
  * Remove the top local environment scope from the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link pushLocalEnvironment} - to add a local scope
  */
-export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+export declare function popLocalEnvironment({ current, level }: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/scoping.js

@@ -8,23 +8,23 @@ const assert_1 = require("../../util/assert");
  * Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link popLocalEnvironment} - to remove the local scope again
  */
-function pushLocalEnvironment(base) {
+function pushLocalEnvironment({ level, current }) {
     return {
-        current: new environment_1.Environment(base.current),
-        level: base.level + 1
+        current: new environment_1.Environment(current),
+        level: level + 1
     };
 }
 /**
  * Remove the top local environment scope from the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone)
  * @see {@link pushLocalEnvironment} - to add a local scope
  */
-function popLocalEnvironment(base) {
-    (0, assert_1.guard)(base.level > 0, 'cannot remove the global/root environment');
-    const parent = base.current.parent;
+function popLocalEnvironment({ current, level }) {
+    (0, assert_1.guard)(level > 0, 'cannot remove the global/root environment');
+    const parent = current.parent;
     (0, assert_1.guard)(parent !== undefined, 'level is wrong, parent is undefined even though level suggested depth > 0 (starts with 0)');
     return {
         current: parent,
-        level: base.level - 1
+        level: level - 1
     };
 }
 //# sourceMappingURL=scoping.js.map

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

@@ -5,6 +5,7 @@ import { type REnvironmentInformation } from '../../environments/environment';
 import { type Identifier } from '../../environments/identifier';
 import type { DataflowGraph } from '../../graph/graph';
 import { type Lift, type Value, type ValueSet } from '../values/r-value';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 export type ResolveResult = Lift<ValueSet<Value[]>>;
 export interface ResolveInfo {
     /** The current environment used for name resolution */
@@ -16,7 +17,9 @@ export interface ResolveInfo {
     /** Whether to track variables */
     full?: boolean;
     /** Variable resolve mode */
-    resolve: VariableResolve;
+    resolve?: VariableResolve;
+    /** Context used for resolving */
+    ctx: ReadOnlyFlowrAnalyzerContext;
 }
 /**
  * Gets the definitions / aliases of a node
@@ -50,8 +53,9 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * @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
+ * @param ctx                - Context used for clean environment
  */
-export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve }: ResolveInfo): ResolveResult;
+export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefined, { environment, graph, idMap, full, resolve, ctx }: ResolveInfo): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *
@@ -60,21 +64,23 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
+ * @param ctx        - analysis context
  * @param graph      - dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-export declare function trackAliasInEnvironments(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+export declare function trackAliasInEnvironments(resolve: VariableResolve, identifier: Identifier | undefined, use: REnvironmentInformation, ctx: ReadOnlyFlowrAnalyzerContext, graph?: DataflowGraph, idMap?: AstIdMap): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
  * @param id    - node to resolve
+ * @param ctx - analysis context
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
  * @returns Value of node or Top/Bottom
  */
-export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, idMap?: AstIdMap): ResolveResult;
+export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap): ResolveResult;
 /**
  * Please use {@link resolveIdToValue}
  *

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

@@ -8,10 +8,8 @@ exports.resolveToConstants = resolveToConstants;
 const config_1 = require("../../../config");
 const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const fingerprint_1 = require("../../../slicing/static/fingerprint");
 const visiting_queue_1 = require("../../../slicing/static/visiting-queue");
 const assert_1 = require("../../../util/assert");
-const environment_1 = require("../../environments/environment");
 const identifier_1 = require("../../environments/identifier");
 const resolve_by_name_1 = require("../../environments/resolve-by-name");
 const edge_1 = require("../../graph/edge");
@@ -47,7 +45,7 @@ function getUseAlias(sourceId, dataflow, environment) {
     if (identifier === undefined) {
         return undefined;
     }
-    const defs = (0, resolve_by_name_1.resolveByName)(identifier, environment);
+    const defs = (0, resolve_by_name_1.resolveByNameAnyType)(identifier, environment);
     if (defs === undefined) {
         return undefined;
     }
@@ -94,7 +92,7 @@ function getAliases(sourceIds, dataflow, environment) {
             definitions.add(def);
         }
     }
-    return [...definitions];
+    return Array.from(definitions);
 }
 /**
  * Evaluates the value of a node in the set domain.
@@ -114,8 +112,10 @@ function getAliases(sourceIds, dataflow, environment) {
  * @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
+ * @param ctx                - Context used for clean environment
  */
-function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve }) {
+function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve, ctx }) {
+    const variableResolve = resolve ?? ctx.config.solver.variables;
     if (id === undefined) {
         return r_value_1.Top;
     }
@@ -128,10 +128,10 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
         case type_1.RType.Argument:
         case type_1.RType.Symbol:
             if (environment) {
-                return full ? trackAliasInEnvironments(resolve, node.lexeme, environment, graph, idMap) : r_value_1.Top;
+                return full ? trackAliasInEnvironments(variableResolve, node.lexeme, environment, ctx, graph, idMap) : r_value_1.Top;
             }
             else if (graph && resolve === config_1.VariableResolve.Alias) {
-                return full ? trackAliasesInGraph(node.info.id, graph, idMap) : r_value_1.Top;
+                return full ? trackAliasesInGraph(node.info.id, graph, ctx, idMap) : r_value_1.Top;
             }
             else {
                 return r_value_1.Top;
@@ -141,7 +141,7 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
         case type_1.RType.FunctionCall:
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:
-            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(resolve, node, environment, graph, idMap));
+            return (0, set_constants_1.setFrom)((0, resolve_1.resolveNode)(variableResolve, node, ctx, environment, graph, idMap));
         case type_1.RType.String:
         case type_1.RType.Number:
         case type_1.RType.Logical:
@@ -158,15 +158,16 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
+ * @param ctx        - analysis context
  * @param graph      - dataflow graph
  * @param idMap      - id map of Dataflow graph
  * @returns Value of Identifier or Top
  */
-function trackAliasInEnvironments(resolve, identifier, use, graph, idMap) {
+function trackAliasInEnvironments(resolve, identifier, use, ctx, graph, idMap) {
     if (identifier === undefined) {
         return r_value_1.Top;
     }
-    const defs = (0, resolve_by_name_1.resolveByName)(identifier, use);
+    const defs = (0, resolve_by_name_1.resolveByNameAnyType)(identifier, use);
     if (defs === undefined) {
         return r_value_1.Top;
     }
@@ -186,7 +187,7 @@ function trackAliasInEnvironments(resolve, identifier, use, graph, idMap) {
             for (const alias of def.value) {
                 const definitionOfAlias = idMap?.get(alias);
                 if (definitionOfAlias !== undefined) {
-                    const value = (0, resolve_1.resolveNode)(resolve, definitionOfAlias, use, graph, idMap);
+                    const value = (0, resolve_1.resolveNode)(resolve, definitionOfAlias, ctx, use, graph, idMap);
                     if ((0, r_value_1.isTop)(value)) {
                         return r_value_1.Top;
                     }
@@ -253,19 +254,20 @@ function isNestedInLoop(node, ast) {
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
  * @param id    - node to resolve
+ * @param ctx - analysis context
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
  * @returns Value of node or Top/Bottom
  */
-function trackAliasesInGraph(id, graph, idMap) {
+function trackAliasesInGraph(id, graph, ctx, idMap) {
     if (!graph.get(id)) {
         return r_value_1.Bottom;
     }
     idMap ??= graph.idMap;
     (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
     const queue = new visiting_queue_1.VisitingQueue(25);
-    const clean = (0, environment_1.initializeCleanEnvironments)();
-    const cleanFingerprint = (0, fingerprint_1.envFingerprint)(clean);
+    const clean = ctx.env.makeCleanEnv();
+    const cleanFingerprint = ctx.env.getCleanEnvFingerprint();
     queue.add(id, clean, cleanFingerprint, false);
     let forceTop = false;
     const resultIds = [];

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

@@ -2,7 +2,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';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 /**
  * 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;
+export declare function getArgumentStringValue(variableResolve: VariableResolve, graph: DataflowGraph, vertex: DataflowGraphVertexFunctionCall, argumentIndex: number | 'unnamed' | undefined, argumentName: string | undefined, resolveValue: boolean | 'library' | undefined, ctx: ReadOnlyFlowrAnalyzerContext): Map<NodeId, Set<string | undefined>> | undefined;

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

@@ -14,7 +14,7 @@ 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) {
+function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, argumentName, resolveValue, ctx) {
     if (argumentName) {
         const arg = vertex?.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argumentName);
         if (arg >= 0) {
@@ -35,7 +35,7 @@ function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, a
             }
             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];
+                const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue, ctx) ?? [dependencies_query_format_1.Unknown];
                 map.set(ref, new Set(values));
             }
         }
@@ -51,17 +51,17 @@ function getArgumentStringValue(variableResolve, graph, vertex, argumentIndex, a
             valueNode = valueNode.value;
         }
         if (valueNode) {
-            const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
+            const values = resolveBasedOnConfig(variableResolve, graph, vertex, valueNode, vertex.environment, graph.idMap, resolveValue, ctx) ?? [dependencies_query_format_1.Unknown];
             return new Map([[arg, new Set(values)]]);
         }
     }
     return undefined;
 }
-function hasCharacterOnly(variableResolve, graph, vertex, idMap) {
+function hasCharacterOnly(variableResolve, graph, vertex, idMap, ctx) {
     if (!vertex.args || vertex.args.length === 0 || !idMap) {
         return false;
     }
-    const treatAsChar = getArgumentStringValue(variableResolve, graph, vertex, 5, 'character.only', true);
+    const treatAsChar = getArgumentStringValue(variableResolve, graph, vertex, 5, 'character.only', true, ctx);
     if (!treatAsChar) {
         return false;
     }
@@ -74,13 +74,13 @@ function hasCharacterOnly(variableResolve, graph, vertex, idMap) {
         return hasTrue;
     }
 }
-function resolveBasedOnConfig(variableResolve, graph, vertex, argument, environment, idMap, resolveValue) {
+function resolveBasedOnConfig(variableResolve, graph, vertex, argument, environment, idMap, resolveValue, ctx) {
     let full = true;
     if (!resolveValue) {
         full = false;
     }
     if (resolveValue === 'library') {
-        const hasChar = hasCharacterOnly(variableResolve, graph, vertex, idMap);
+        const hasChar = hasCharacterOnly(variableResolve, graph, vertex, idMap, ctx);
         if (hasChar === false) {
             if (argument.type === type_1.RType.Symbol) {
                 return [argument.lexeme];
@@ -88,7 +88,7 @@ function resolveBasedOnConfig(variableResolve, graph, vertex, argument, environm
             full = false;
         }
     }
-    const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(argument, { environment, graph, full, resolve: variableResolve }));
+    const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(argument, { environment, graph, full, resolve: variableResolve, ctx }));
     if (resolved) {
         const values = [];
         for (const value of resolved.elements) {

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

@@ -1,8 +1,9 @@
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { REnvironmentInformation } from '../../environments/environment';
 import type { DataflowGraph } from '../../graph/graph';
-import { type Lift, type Value, type ValueNumber, type ValueVector, Top } from '../values/r-value';
+import { type Lift, Top, type Value, type ValueNumber, type ValueVector } from '../values/r-value';
 import type { VariableResolve } from '../../../config';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -16,21 +17,22 @@ import type { VariableResolve } from '../../../config';
  * @param map     - Idmap of Dataflow Graph
  * @returns resolved value or top/bottom
  */
-export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, 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 an identifier / node
  *
  * 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 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
+ * @param resolve     - Variable resolve mode
+ * @param node        - Node of the vector function to resolve
+ * @param environment - Environment to use
+ * @param ctx         - Analyzer context
+ * @param graph       - Dataflow graph
+ * @param idMap       - ID map of the dataflow graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<Value[]>> | typeof Top;
+export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<Value[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -44,7 +46,7 @@ export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWit
  * @param map      - Id map of the dataflow graph
  * @returns ValueVector of ValueNumbers or Top
  */
-export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -58,7 +60,7 @@ export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWi
  * @param map      - Id map of the dataflow graph
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
@@ -72,4 +74,4 @@ export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeW
  * @param map      - Id map of the dataflow graph
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;

package/dataflow/eval/resolve/resolve.js

@@ -30,7 +30,7 @@ const scalar_consatnts_1 = require("../values/scalar/scalar-consatnts");
  * @param map     - Idmap of Dataflow Graph
  * @returns resolved value or top/bottom
  */
-function resolveNode(resolve, a, env, graph, map) {
+function resolveNode(resolve, a, ctx, env, graph, map) {
     if (a.type === type_1.RType.String) {
         return (0, string_constants_1.stringFrom)(a.content.str);
     }
@@ -63,7 +63,7 @@ function resolveNode(resolve, a, env, graph, map) {
         }
         if (Object.hasOwn(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
             const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
-            return handler(resolve, a, env, graph, map);
+            return handler(resolve, a, ctx, env, graph, map);
         }
     }
     return r_value_2.Top;
@@ -74,18 +74,19 @@ function resolveNode(resolve, a, env, graph, map) {
  *
  * 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 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
+ * @param resolve     - Variable resolve mode
+ * @param node        - Node of the vector function to resolve
+ * @param environment - Environment to use
+ * @param ctx         - Analyzer context
+ * @param graph       - Dataflow graph
+ * @param idMap       - ID map of the dataflow graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(resolve, node, environment, graph, idMap) {
+function resolveAsVector(resolve, node, ctx, environment, graph, idMap) {
     if (node.type !== type_1.RType.FunctionCall) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
     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));
 }
@@ -102,11 +103,11 @@ function resolveAsVector(resolve, node, environment, graph, idMap) {
  * @param map      - Id map of the dataflow graph
  * @returns ValueVector of ValueNumbers or Top
  */
-function resolveAsSeq(resolve, operator, environment, graph, idMap) {
+function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
     if (operator.type !== type_1.RType.BinaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
     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);
@@ -129,11 +130,11 @@ function resolveAsSeq(resolve, operator, environment, graph, idMap) {
  * @param map      - Id map of the dataflow graph
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-function resolveAsPlus(resolve, operator, environment, graph, idMap) {
+function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
     if (operator.type !== type_1.RType.UnaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
     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)) {
@@ -157,11 +158,11 @@ function resolveAsPlus(resolve, operator, environment, graph, idMap) {
  * @param map      - Id map of the dataflow graph
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-function resolveAsMinus(resolve, operator, environment, graph, idMap) {
+function resolveAsMinus(resolve, operator, ctx, environment, graph, idMap) {
     if (operator.type !== type_1.RType.UnaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
     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)) {

package/dataflow/extractor.js

@@ -14,13 +14,11 @@ const named_call_handling_1 = require("./internal/process/functions/call/named-c
 const make_argument_1 = require("./internal/process/functions/call/argument/make-argument");
 const range_1 = require("../util/range");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
-const environment_1 = require("./environments/environment");
 const built_in_source_1 = require("./internal/process/functions/call/built-in/built-in-source");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const edge_1 = require("./graph/edge");
 const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
-const built_in_config_1 = require("./environments/built-in-config");
 const flowr_file_1 = require("../project/context/flowr-file");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
@@ -95,17 +93,13 @@ function resolveLinkToSideEffects(ast, graph) {
  * For the actual, canonical fold entry point, see {@link processDataflowFor}.
  */
 function produceDataFlowGraph(parser, completeAst, ctx) {
-    const builtInsConfig = ctx.config.semantics.environment.overwriteBuiltIns;
-    const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
-    const env = (0, environment_1.initializeCleanEnvironments)(builtIns.builtInMemory);
     // we freeze the files here to avoid endless modifications during processing
     const files = completeAst.ast.files.slice();
     ctx.files.addConsideredFile(files[0].filePath ? files[0].filePath : flowr_file_1.FlowrFile.INLINE_PATH);
     const dfData = {
         parser,
         completeAst,
-        environment: env,
-        builtInEnvironment: env.current.parent,
+        environment: ctx.env.makeCleanEnv(),
         processors: exports.processors,
         controlDependencies: undefined,
         referenceChain: [files[0].filePath],