@eagleoutice/flowr 2.6.3 → 2.7.0

package/linter/rules/absolute-path.js

@@ -49,15 +49,15 @@ function buildQuickFix(str, filePath, wd) {
 }
 /** return all strings constructable by these functions */
 const PathFunctions = {
-    'file.path': (df, vtx, config) => {
-        const fsep = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, undefined, 'fsep', true);
+    'file.path': (df, vtx, ctx) => {
+        const fsep = (0, resolve_argument_1.getArgumentStringValue)(ctx.config.solver.variables, df, vtx, undefined, 'fsep', true, ctx);
         // in the future we can access `.Platform$file.sep` here
         const sepValues = fsep?.values()?.flatMap(s => s.values().filter(assert_1.isNotUndefined)).toArray() ?? [path_1.default.sep];
         if (sepValues.some(s => s === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(s))) {
             // if we have no fsep, we cannot construct a path
             return undefined;
         }
-        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, 'unnamed', undefined, true);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(ctx.config.solver.variables, df, vtx, 'unnamed', undefined, true, ctx);
         const argValues = args ? Array.from(args.values()).flatMap(v => [...v]) : [];
         if (!argValues || argValues.length === 0 || argValues.some(v => v === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(v))) {
             // if we have no arguments, we cannot construct a path
@@ -139,7 +139,7 @@ exports.ABSOLUTE_PATH = {
                     const dfNode = data.dataflow.graph.getVertex(node.info.id);
                     if ((0, vertex_1.isFunctionCallVertex)(dfNode)) {
                         const handler = PathFunctions[dfNode.name ?? ''];
-                        const strings = handler ? handler(data.dataflow.graph, dfNode, data.analyzer.flowrConfig) : [];
+                        const strings = handler ? handler(data.dataflow.graph, dfNode, data.analyzer.inspectContext()) : [];
                         if (strings) {
                             return strings.filter(s => (0, strings_1.isAbsolutePath)(s, regex)).map(str => ({
                                 certainty: linter_format_1.LintingResultCertainty.Uncertain,

package/linter/rules/dataframe-access-validation.d.ts

@@ -47,7 +47,7 @@ export declare const DATA_FRAME_ACCESS_VALIDATION: {
         readonly name: "Dataframe Access Validation";
         readonly tags: readonly [LintingRuleTag.Bug, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
         readonly certainty: LintingRuleCertainty.BestEffort;
-        readonly description: "Validates the existance of accessed columns and rows of dataframes.";
+        readonly description: "Validates the existence of accessed columns and rows of dataframes.";
         readonly defaultConfig: {
             readonly readLoadedData: false;
         };

package/linter/rules/dataframe-access-validation.js

@@ -85,7 +85,7 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
         tags: [linter_tags_1.LintingRuleTag.Bug, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
         // this rule is unable to detect all cases of dataframe access, but sufficiently ensures returned results are valid
         certainty: linter_format_1.LintingRuleCertainty.BestEffort,
-        description: 'Validates the existance of accessed columns and rows of dataframes.',
+        description: 'Validates the existence of accessed columns and rows of dataframes.',
         defaultConfig: { readLoadedData: false }
     }
 };

package/linter/rules/function-finder-util.d.ts

@@ -5,8 +5,8 @@ import type { FlowrSearchElement, FlowrSearchElements } from '../../search/flowr
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { MergeableRecord } from '../../util/objects';
 import type { DataflowInformation } from '../../dataflow/info';
-import type { FlowrConfigOptions } from '../../config';
 import type { FunctionInfo } from '../../queries/catalog/dependencies-query/function-info/function-info';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export interface FunctionsResult extends LintingResult {
     function: string;
     range: SourceRange;
@@ -41,6 +41,6 @@ export declare const functionFinderUtil: {
     requireArgumentValue(element: FlowrSearchElement<ParentInformation>, pool: readonly FunctionInfo[], data: {
         normalize: NormalizedAst;
         dataflow: DataflowInformation;
-        config: FlowrConfigOptions;
+        analyzer: ReadonlyFlowrAnalysisProvider;
     }, requireValue: RegExp | string | undefined): boolean;
 };

package/linter/rules/function-finder-util.js

@@ -65,7 +65,7 @@ exports.functionFinderUtil = {
         }
         const vert = data.dataflow.graph.getVertex(element.node.info.id);
         if ((0, vertex_1.isFunctionCallVertex)(vert)) {
-            const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue);
+            const args = (0, resolve_argument_1.getArgumentStringValue)(data.analyzer.flowrConfig.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
             // we obtain all values, at least one of them has to trigger for the request
             const argValues = args ? args.values().flatMap(v => [...v]).filter(assert_1.isNotUndefined).toArray() : [];
             /* if there are no arguments we assume they may access the network, otherwise we check for the flag */

package/linter/rules/network-functions.js

@@ -7,7 +7,7 @@ const linter_tags_1 = require("../linter-tags");
 const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
 exports.NETWORK_FUNCTIONS = {
     createSearch: (config) => function_finder_util_1.functionFinderUtil.createSearch(config.fns),
-    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, { config: d.analyzer.flowrConfig, dataflow: d.dataflow, normalize: d.normalize }, c.onlyTriggerWithArgument))),
+    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, { analyzer: d.analyzer, dataflow: d.dataflow, normalize: d.normalize }, c.onlyTriggerWithArgument))),
     prettyPrint: function_finder_util_1.functionFinderUtil.prettyPrint('network operations'),
     info: {
         name: 'Network Functions',

package/linter/rules/seeded-randomness.d.ts

@@ -31,7 +31,7 @@ export interface SeededRandomnessMeta extends MergeableRecord {
 }
 export declare const SEEDED_RANDOMNESS: {
     readonly createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "with"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
-    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: SeededRandomnessConfig, { dataflow }: {
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: SeededRandomnessConfig, { dataflow, analyzer }: {
         normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
         cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;

package/linter/rules/seeded-randomness.js

@@ -31,7 +31,7 @@ exports.SEEDED_RANDOMNESS = {
         { callName: config.randomnessProducers.filter(p => p.type === 'function').map(p => p.name) },
         { callName: getDefaultAssignments().flatMap(b => b.names), cascadeIf: () => cascade_action_1.CascadeAction.Continue }
     ]),
-    processSearchResult: (elements, config, { dataflow }) => {
+    processSearchResult: (elements, config, { dataflow, analyzer }) => {
         const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
         const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([n, a.config?.swapSourceAndTarget ? 1 : 0]))));
         const metadata = {
@@ -63,7 +63,7 @@ exports.SEEDED_RANDOMNESS = {
                 let otherBranch = false;
                 // function calls are already taken care of through the LastCall enrichment itself
                 for (const f of func ?? []) {
-                    if (isConstantArgument(dataflow.graph, f, 0)) {
+                    if (isConstantArgument(dataflow.graph, f, 0, analyzer.inspectContext())) {
                         const fCds = new Set(f.cds).difference(cds);
                         if (fCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(fCds)) {
                             metadata.callsWithFunctionProducers++;
@@ -83,7 +83,7 @@ exports.SEEDED_RANDOMNESS = {
                     const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
                     if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
                         // we either have arg index 0 or 1 for the assignmentProducers destination, so we select the assignment value as 1-argIdx here
-                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx)) {
+                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx, analyzer.inspectContext())) {
                             const aCds = new Set(a.cds).difference(cds);
                             if (aCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(aCds)) {
                                 metadata.callsWithAssignmentProducers++;
@@ -132,9 +132,9 @@ exports.SEEDED_RANDOMNESS = {
 function getDefaultAssignments() {
     return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && b.processor == 'builtin:assignment');
 }
-function isConstantArgument(graph, call, argIndex) {
+function isConstantArgument(graph, call, argIndex, ctx) {
     const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
-    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias }));
+    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias, ctx }));
     return values?.elements.every(v => v.type === 'number' ||
         v.type === 'logical' ||
         v.type === 'string' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.6.3",
+  "version": "2.7.0",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -28,7 +28,6 @@
     "capabilities-markdown": "ts-node src/documentation/doc-capabilities.ts",
     "wiki": "ts-node src/cli/wiki.ts",
     "wiki:watch": "ts-node-dev src/cli/wiki.ts -- --keep-alive",
-    "wiki:linter": "ts-node src/documentation/wiki-linter.ts",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",

package/project/context/flowr-analyzer-context.d.ts

@@ -4,6 +4,8 @@ import { type FlowrAnalyzerPlugin, PluginType } from '../plugins/flowr-analyzer-
 import type { fileProtocol, RParseRequestFromFile, RParseRequests } from '../../r-bridge/retriever';
 import type { FlowrConfigOptions } from '../../config';
 import type { FlowrFileProvider } from './flowr-file';
+import type { ReadOnlyFlowrAnalyzerEnvironmentContext } from './flowr-analyzer-environment-context';
+import { FlowrAnalyzerEnvironmentContext } from './flowr-analyzer-environment-context';
 /**
  * This is a read-only interface to the {@link FlowrAnalyzerContext}.
  * It prevents you from modifying the context, but allows you to inspect it (which is probably what you want when using the {@link FlowrAnalyzer}).
@@ -18,6 +20,10 @@ export interface ReadOnlyFlowrAnalyzerContext {
      * The dependencies context provides access to the identified dependencies and their versions.
      */
     readonly deps: ReadOnlyFlowrAnalyzerDependenciesContext;
+    /**
+     * The environment context provides access to the environment information used during analysis.
+     */
+    readonly env: ReadOnlyFlowrAnalyzerEnvironmentContext;
     /**
      * The configuration options used by the analyzer.
      */
@@ -38,6 +44,7 @@ export interface ReadOnlyFlowrAnalyzerContext {
 export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContext {
     readonly files: FlowrAnalyzerFilesContext;
     readonly deps: FlowrAnalyzerDependenciesContext;
+    readonly env: FlowrAnalyzerEnvironmentContext;
     readonly config: FlowrConfigOptions;
     constructor(config: FlowrConfigOptions, plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
     /** delegate request addition */

package/project/context/flowr-analyzer-context.js

@@ -11,6 +11,7 @@ const arrays_1 = require("../../util/collections/arrays");
 const retriever_1 = require("../../r-bridge/retriever");
 const config_1 = require("../../config");
 const flowr_file_1 = require("./flowr-file");
+const flowr_analyzer_environment_context_1 = require("./flowr-analyzer-environment-context");
 /**
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
  * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
@@ -26,12 +27,14 @@ const flowr_file_1 = require("./flowr-file");
 class FlowrAnalyzerContext {
     files;
     deps;
+    env;
     config;
     constructor(config, plugins) {
         this.config = config;
         const loadingOrder = new flowr_analyzer_loading_order_context_1.FlowrAnalyzerLoadingOrderContext(this, plugins.get(flowr_analyzer_plugin_1.PluginType.LoadingOrder));
         this.files = new flowr_analyzer_files_context_1.FlowrAnalyzerFilesContext(loadingOrder, (plugins.get(flowr_analyzer_plugin_1.PluginType.ProjectDiscovery) ?? []), (plugins.get(flowr_analyzer_plugin_1.PluginType.FileLoad) ?? []));
         this.deps = new flowr_analyzer_dependencies_context_1.FlowrAnalyzerDependenciesContext(this, (plugins.get(flowr_analyzer_plugin_1.PluginType.DependencyIdentification) ?? []));
+        this.env = new flowr_analyzer_environment_context_1.FlowrAnalyzerEnvironmentContext(this);
     }
     /** delegate request addition */
     addRequests(requests) {

package/project/context/flowr-analyzer-environment-context.d.ts

@@ -0,0 +1,47 @@
+import type { FlowrAnalyzerContext } from './flowr-analyzer-context';
+import type { IEnvironment, REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { DeepReadonly } from 'ts-essentials';
+import type { Fingerprint } from '../../slicing/static/fingerprint';
+/**
+ * This is the read-only interface to the {@link FlowrAnalyzerEnvironmentContext},
+ * which provides access to the built-in environment used during analysis.
+ */
+export interface ReadOnlyFlowrAnalyzerEnvironmentContext {
+    /**
+     * Get the built-in environment used during analysis.
+     */
+    get builtInEnvironment(): DeepReadonly<IEnvironment>;
+    /**
+     * Get the empty built-in environment used during analysis.
+     * The empty built-in environment only contains primitive definitions.
+     */
+    get emptyBuiltInEnvironment(): DeepReadonly<IEnvironment>;
+    /**
+     * Create a new {@link REnvironmentInformation|environment} with the configured built-in environment as base.
+     */
+    makeCleanEnv(): REnvironmentInformation;
+    /**
+     * Get the fingerprint of the clean environment with the configured built-in environment as base.
+     */
+    getCleanEnvFingerprint(): Fingerprint;
+    /**
+     * Create a new {@link REnvironmentInformation|environment} with an empty built-in environment as base.
+     */
+    makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+}
+/**
+ * This context is responsible for providing the built-in environment.
+ * It creates the built-in environment based on the configuration provided in the {@link FlowrAnalyzerContext}.
+ */
+export declare class FlowrAnalyzerEnvironmentContext implements ReadOnlyFlowrAnalyzerEnvironmentContext {
+    readonly name = "flowr-analyzer-environment-context";
+    private readonly builtInEnv;
+    private readonly emptyBuiltInEnv;
+    private builtInEnvFingerprint;
+    constructor(ctx: FlowrAnalyzerContext);
+    get builtInEnvironment(): DeepReadonly<IEnvironment>;
+    get emptyBuiltInEnvironment(): DeepReadonly<IEnvironment>;
+    makeCleanEnv(): REnvironmentInformation;
+    getCleanEnvFingerprint(): Fingerprint;
+    makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+}

package/project/context/flowr-analyzer-environment-context.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerEnvironmentContext = void 0;
+const environment_1 = require("../../dataflow/environments/environment");
+const built_in_config_1 = require("../../dataflow/environments/built-in-config");
+const fingerprint_1 = require("../../slicing/static/fingerprint");
+/**
+ * This context is responsible for providing the built-in environment.
+ * It creates the built-in environment based on the configuration provided in the {@link FlowrAnalyzerContext}.
+ */
+class FlowrAnalyzerEnvironmentContext {
+    name = 'flowr-analyzer-environment-context';
+    builtInEnv;
+    emptyBuiltInEnv;
+    builtInEnvFingerprint;
+    constructor(ctx) {
+        const builtInsConfig = ctx.config.semantics.environment.overwriteBuiltIns;
+        const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
+        this.builtInEnv = new environment_1.Environment(undefined, true);
+        this.builtInEnv.memory = builtIns.builtInMemory;
+        this.emptyBuiltInEnv = new environment_1.Environment(undefined, true);
+        this.emptyBuiltInEnv.memory = builtIns.emptyBuiltInMemory;
+    }
+    get builtInEnvironment() {
+        return this.builtInEnv;
+    }
+    get emptyBuiltInEnvironment() {
+        return this.emptyBuiltInEnv;
+    }
+    makeCleanEnv() {
+        return {
+            current: new environment_1.Environment(this.builtInEnv),
+            level: 0
+        };
+    }
+    getCleanEnvFingerprint() {
+        if (!this.builtInEnvFingerprint) {
+            this.builtInEnvFingerprint = (0, fingerprint_1.envFingerprint)(this.makeCleanEnv());
+        }
+        return this.builtInEnvFingerprint;
+    }
+    makeCleanEnvWithEmptyBuiltIns() {
+        return {
+            current: new environment_1.Environment(this.emptyBuiltInEnv),
+            level: 0
+        };
+    }
+}
+exports.FlowrAnalyzerEnvironmentContext = FlowrAnalyzerEnvironmentContext;
+//# sourceMappingURL=flowr-analyzer-environment-context.js.map

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -192,10 +192,7 @@ async function executeCallContextQueries({ analyzer }, queries) {
         cfg = await analyzer.controlflow([], cfg_kind_1.CfgKind.WithDataflow);
     }
     const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
-    for (const [nodeId, info] of dataflow.graph.vertices(true)) {
-        if (info.tag !== vertex_1.VertexType.FunctionCall) {
-            continue;
-        }
+    for (const [nodeId, info] of dataflow.graph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
         /* if we have a vertex, and we check for aliased calls, we want to know if we define this as desired! */
         if (queriesWhichWantAliases.length > 0) {
             /*

package/queries/catalog/control-flow-query/control-flow-query-format.js

@@ -26,9 +26,10 @@ exports.ControlFlowQueryDefinition = {
     }).description('The control flow query provides the control flow graph of the analysis, optionally simplified.'),
     flattenInvolvedNodes: (queryResults) => {
         const out = queryResults;
-        return [...out.controlFlow.graph.vertices(true)]
+        return out.controlFlow.graph.vertices(true).entries()
             .filter(([, v]) => v.type !== control_flow_graph_1.CfgVertexType.Block)
-            .map(v => v[0]);
+            .map(v => v[0])
+            .toArray();
     }
 };
 //# sourceMappingURL=control-flow-query-format.js.map

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-executor.js

@@ -20,7 +20,7 @@ async function executeDataflowLensQuery({ analyzer }, queries) {
             nameRegex: '<-|<<-|->|->>|=|+|-|*|/|\\|>|function|repeat|if|next|break',
             blacklistWithName: true
         }
-    });
+    }, analyzer.inspectContext().env.makeCleanEnv());
     const timing = Date.now() - now;
     return {
         '.meta': {

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -76,8 +76,8 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
         const vertex = dataflow.graph.getVertex(id);
         const info = functionMap.get(name);
-        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
-        const linkedArgs = collectValuesFromLinks(args, { dataflow, config }, linkedIds);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
+        const linkedArgs = collectValuesFromLinks(args, { dataflow, config, ctx: data.analyzer.inspectContext() }, linkedIds);
         const linked = dropInfoOnLinkedIds(linkedIds);
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
@@ -97,7 +97,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
             (0, assert_1.guard)('mode' in (info.additionalArgs ?? {}), 'Need additional argument mode when checking for mode');
             const margs = info.additionalArgs?.mode;
             (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
-            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
+            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
             const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
             if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
                 // all modes are read-only, so we can ignore this
@@ -159,7 +159,7 @@ function collectValuesFromLinks(args, data, linkedIds) {
         if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
             continue;
         }
-        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.ctx);
         if (args === undefined) {
             continue;
         }

package/queries/catalog/df-shape-query/df-shape-query-executor.d.ts

@@ -1,6 +1,6 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { DfShapeQuery, DfShapeQueryResult } from './df-shape-query-format';
 /**
- * Executes the given dataframe shape queries using the provided analyzer.
+ * Executes the given data frame shape queries using the provided analyzer.
  */
 export declare function executeDfShapeQuery({ analyzer }: BasicQueryData, queries: readonly DfShapeQuery[]): Promise<DfShapeQueryResult>;

package/queries/catalog/df-shape-query/df-shape-query-executor.js

@@ -5,7 +5,7 @@ const shape_inference_1 = require("../../../abstract-interpretation/data-frame/s
 const parse_1 = require("../../../slicing/criterion/parse");
 const log_1 = require("../../../util/log");
 /**
- * Executes the given dataframe shape queries using the provided analyzer.
+ * Executes the given data frame shape queries using the provided analyzer.
  */
 async function executeDfShapeQuery({ analyzer }, queries) {
     if (queries.length !== 1 && queries.some(query => query.criterion === undefined)) {

package/queries/catalog/df-shape-query/df-shape-query-format.d.ts

@@ -1,11 +1,11 @@
+import Joi from 'joi';
 import { type DataFrameDomain, DataFrameStateDomain } from '../../../abstract-interpretation/data-frame/dataframe-domain';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { ParsedQueryLine } from '../../query';
 import { executeDfShapeQuery } from './df-shape-query-executor';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
-import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
-import type { FlowrConfigOptions } from '../../../config';
-import Joi from 'joi';
 /** Infer the shape of data frames using abstract interpretation. */
 export interface DfShapeQuery extends BaseQueryFormat {
     readonly type: 'df-shape';

package/queries/catalog/df-shape-query/df-shape-query-format.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfShapeQueryDefinition = void 0;
+const joi_1 = __importDefault(require("joi"));
 const dataframe_domain_1 = require("../../../abstract-interpretation/data-frame/dataframe-domain");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const df_shape_query_executor_1 = require("./df-shape-query-executor");
-const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
-const joi_1 = __importDefault(require("joi"));
 function dfShapeQueryLineParser(_output, line, _config) {
     const criterion = (0, slice_query_parser_1.sliceCriterionParser)(line[0]);
     return {

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -32,11 +32,11 @@ async function executeHigherOrderQuery({ analyzer }, queries) {
         }
     }
     const graph = (await analyzer.dataflow()).graph;
-    const fns = graph.vertices(true)
-        .filter(([, v]) => (0, vertex_1.isFunctionDefinitionVertex)(v) && (filterFor.size === 0 || filterFor.has(v.id)));
+    const fns = graph.verticesOfType(vertex_1.VertexType.FunctionDefinition)
+        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
     const result = {};
     for (const [id,] of fns) {
-        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph);
+        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph, analyzer.inspectContext());
     }
     return {
         '.meta': {

package/queries/catalog/resolve-value-query/resolve-value-query-executor.js

@@ -26,7 +26,7 @@ async function executeResolveValueQuery({ analyzer }, queries) {
         }
         const values = query.criteria
             .map(criteria => (0, parse_1.slicingCriterionToId)(criteria, ast.idMap))
-            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap, resolve: analyzer.flowrConfig.solver.variables }));
+            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap, resolve: analyzer.flowrConfig.solver.variables, ctx: analyzer.inspectContext() }));
         results[key] = {
             values: values
         };

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -30,7 +30,7 @@ async function executeStaticSliceQuery({ analyzer }, queries) {
         }
         const { criteria, noReconstruction, noMagicComments } = query;
         const sliceStart = Date.now();
-        const slice = (0, static_slicer_1.staticSlice)(await analyzer.dataflow(), await analyzer.normalize(), criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, analyzer.flowrConfig.solver.slicer?.threshold);
+        const slice = (0, static_slicer_1.staticSlice)(analyzer.inspectContext(), await analyzer.dataflow(), await analyzer.normalize(), criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, analyzer.flowrConfig.solver.slicer?.threshold);
         const sliceEnd = Date.now();
         if (noReconstruction) {
             results[key] = { slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } } };

package/slicing/static/slice-call.d.ts

@@ -6,11 +6,12 @@ import type { REnvironmentInformation } from '../../dataflow/environments/enviro
 import { type DataflowGraph, type OutgoingEdges } from '../../dataflow/graph/graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
+export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
 /** returns the new threshold hit count */
-export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue): void;
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): void;
 /** Returns true if we found at least one return edge */
 export declare function handleReturns(from: NodeId, queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -16,12 +16,12 @@ const static_slicer_1 = require("./static-slicer");
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, queue) {
+function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, queue, ctx) {
     // bind with call-local environments during slicing
     const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
     (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
     // lift baseEnv on the same level
-    const activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment);
+    const activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment, ctx);
     const name = callerInfo.name;
     (0, assert_1.guard)(name !== undefined, () => `name of id: ${callerInfo.id} can not be found in id map`);
     const functionCallDefs = (0, resolve_by_name_1.resolveByName)(name, activeEnvironment, identifier_1.ReferenceType.Unknown)?.filter(d => !(0, built_in_1.isBuiltIn)(d.definedAt))?.map(d => d.nodeId) ?? [];
@@ -59,9 +59,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
     }
 }
 /** returns the new threshold hit count */
-function sliceForCall(current, callerInfo, dataflowInformation, queue) {
+function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
     const baseEnvironment = current.baseEnvironment;
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue, ctx);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
         /*

package/slicing/static/static-slicer.d.ts

@@ -7,11 +7,13 @@ import { type REnvironmentInformation } from '../../dataflow/environments/enviro
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
+ * @param ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
@@ -19,7 +21,7 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-export declare function staticSlice(info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+export declare function staticSlice(ctx: ReadOnlyFlowrAnalyzerContext, info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
 /**
  * Updates the potential addition for the given target node in the visiting queue.
  * This describes vertices that might be added *if* another path reaches them.

package/slicing/static/static-slicer.js

@@ -5,11 +5,9 @@ exports.staticSlice = staticSlice;
 exports.updatePotentialAddition = updatePotentialAddition;
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
-const fingerprint_1 = require("./fingerprint");
 const visiting_queue_1 = require("./visiting-queue");
 const slice_call_1 = require("./slice-call");
 const parse_1 = require("../criterion/parse");
-const environment_1 = require("../../dataflow/environments/environment");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const edge_1 = require("../../dataflow/graph/edge");
 const _00_slice_1 = require("../../core/steps/all/static-slicing/00-slice");
@@ -19,6 +17,7 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
+ * @param ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
@@ -26,21 +25,21 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-function staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache) {
+function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75, cache) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
     const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
     (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating ${direction} slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
     let { graph } = info;
     if (direction === _00_slice_1.SliceDirection.Forward) {
-        graph = (0, invert_dfg_1.invertDfg)(graph);
+        graph = (0, invert_dfg_1.invertDfg)(graph, ctx.env.makeCleanEnv());
     }
     const queue = new visiting_queue_1.VisitingQueue(threshold, cache);
     let minNesting = Number.MAX_SAFE_INTEGER;
     const sliceSeedIds = new Set();
     // every node ships the call environment which registers the calling environment
     {
-        const emptyEnv = (0, environment_1.initializeCleanEnvironments)();
-        const basePrint = (0, fingerprint_1.envFingerprint)(emptyEnv);
+        const emptyEnv = ctx.env.makeCleanEnv();
+        const basePrint = ctx.env.getCleanEnvFingerprint();
         for (const { id: startId } of decodedCriteria) {
             queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum nesting of all nodes to only add control dependencies if they are "part" of the current execution
@@ -77,7 +76,7 @@ function staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache
         }
         if (!onlyForSideEffects) {
             if (currentVertex.tag === vertex_1.VertexType.FunctionCall && !currentVertex.onlyBuiltin) {
-                (0, slice_call_1.sliceForCall)(current, currentVertex, info, queue);
+                (0, slice_call_1.sliceForCall)(current, currentVertex, info, queue, ctx);
             }
             const ret = (0, slice_call_1.handleReturns)(id, queue, currentEdges, baseEnvFingerprint, baseEnvironment);
             if (ret) {

package/statistics/features/supported/control-flow/control-flow.js

@@ -23,7 +23,7 @@ function visitIfThenElse(info, input) {
     (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.IfThenElse) {
             if (node.type === type_1.RType.FunctionCall && node.named && node.functionName.content === 'switch') {
-                const initialArg = (0, unpack_argument_1.unpackArgument)(node.arguments[0]);
+                const initialArg = (0, unpack_argument_1.unpackNonameArg)(node.arguments[0]);
                 if (initialArg) {
                     info.switchCase = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.switchCase, initialArg);
                 }

package/statistics/features/supported/used-functions/used-functions.js

@@ -84,7 +84,7 @@ function visitCalls(info, input) {
                 hasCallsEdge ? 1 : 0
             ]);
         }
-        classifyArguments(node.arguments.map(e => (0, unpack_argument_1.unpackArgument)(e)), info.args);
+        classifyArguments(node.arguments.map(e => (0, unpack_argument_1.unpackNonameArg)(e)), info.args);
         calls.push(node);
     }, node => {
         // drop again :D