@eagleoutice/flowr 2.6.3 → 2.7.2

package/cli/flowr.d.ts

@@ -1,4 +1,3 @@
-import commandLineUsage from 'command-line-usage';
 export declare const toolName = "flowr";
 export interface FlowrCliOptions {
     'config-file': string;
@@ -32,6 +31,107 @@ export declare const optionHelp: ({
     optionList?: undefined;
 } | {
     header: string;
-    optionList: commandLineUsage.OptionDefinition[];
+    optionList: [{
+        readonly name: "config-file";
+        readonly type: StringConstructor;
+        readonly description: "The name of the configuration file to use";
+        readonly multiple: false;
+    }, {
+        readonly name: "config-json";
+        readonly type: StringConstructor;
+        readonly description: "The flowR configuration to use, as a JSON string";
+        readonly multiple: false;
+    }, {
+        readonly name: "execute";
+        readonly alias: "e";
+        readonly type: StringConstructor;
+        readonly description: "Execute the given command and exit. Use a semicolon \";\" to separate multiple commands.";
+        readonly typeLabel: "{underline command}";
+        readonly multiple: false;
+    }, {
+        readonly name: "help";
+        readonly alias: "h";
+        readonly type: BooleanConstructor;
+        readonly description: "Print this usage guide (or the guide of the corresponding script)";
+    }, {
+        readonly name: "no-ansi";
+        readonly type: BooleanConstructor;
+        readonly description: "Disable ansi-escape-sequences in the output. Useful, if you want to redirect the output to a file.";
+    }, {
+        readonly name: "port";
+        readonly type: NumberConstructor;
+        readonly description: "The port to listen on, if --server is given.";
+        readonly defaultValue: 1042;
+        readonly typeLabel: "{underline port}";
+    }, {
+        readonly name: "r-path";
+        readonly type: StringConstructor;
+        readonly description: "The path to the R executable to use. Defaults to your PATH. This option is being phased out in favor of the engine configuration option \"engine.r-shell.r-path\", which should be used instead.";
+        readonly multiple: false;
+    }, {
+        readonly name: "r-session-access";
+        readonly type: BooleanConstructor;
+        readonly description: "Allow to access the underlying R session when using flowR (security warning: this allows the execution of arbitrary R code!)";
+    }, {
+        readonly name: "script";
+        readonly alias: "s";
+        readonly type: StringConstructor;
+        readonly description: `The sub-script to run (${string})`;
+        readonly multiple: false;
+        readonly defaultOption: true;
+        readonly typeLabel: "{underline files}";
+        readonly defaultValue: undefined;
+    }, {
+        readonly name: "server";
+        readonly type: BooleanConstructor;
+        readonly description: "Do not drop into a repl, but instead start a server on the given port (default: 1042) and listen for messages.";
+    }, {
+        readonly name: "verbose";
+        readonly alias: "v";
+        readonly type: BooleanConstructor;
+        readonly description: "Run with verbose logging (will be passed to the corresponding script)";
+    }, {
+        readonly name: "version";
+        readonly alias: "V";
+        readonly type: BooleanConstructor;
+        readonly description: "Provide information about the version of flowR as well as its underlying R system and exit.";
+    }, {
+        readonly name: "ws";
+        readonly type: BooleanConstructor;
+        readonly description: "If the server flag is set, use websocket for messaging";
+    }, {
+        readonly name: "engine.r-shell.disabled";
+        readonly type: BooleanConstructor;
+        readonly description: "Disable the R shell engine";
+    }, {
+        readonly name: "engine.r-shell.r-path";
+        readonly type: StringConstructor;
+        readonly description: "The path to the R executable to use. Defaults to your PATH.";
+        readonly multiple: false;
+    }, {
+        readonly name: "engine.tree-sitter.disabled";
+        readonly type: BooleanConstructor;
+        readonly description: "Disable the tree-sitter engine";
+    }, {
+        readonly name: "engine.tree-sitter.wasm-path";
+        readonly type: StringConstructor;
+        readonly description: "The path to the tree-sitter-r WASM binary to use. Defaults to the one shipped with flowR.";
+        readonly multiple: false;
+    }, {
+        readonly name: "engine.tree-sitter.tree-sitter-wasm-path";
+        readonly type: StringConstructor;
+        readonly description: "The path to the tree-sitter WASM binary to use. Defaults to the path specified by the tree-sitter package.";
+        readonly multiple: false;
+    }, {
+        readonly name: "engine.tree-sitter.lax";
+        readonly type: BooleanConstructor;
+        readonly description: "Use the lax parser for parsing R code (allowing for syntax errors).";
+        readonly multiple: false;
+    }, {
+        readonly name: "default-engine";
+        readonly type: StringConstructor;
+        readonly description: "The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from the specified list will be used.";
+        readonly multiple: false;
+    }];
     content?: undefined;
 })[];

package/cli/repl/commands/repl-commands.d.ts

@@ -1,5 +1,29 @@
 import type { ReplCodeCommand, ReplCommand } from './repl-main';
+import { scripts } from '../../common/scripts-info';
 export declare const helpCommand: ReplCommand;
+/**
+ * All commands that should be available in the REPL.
+ */
+declare const _commands: {
+    readonly help: ReplCommand;
+    readonly quit: ReplCommand;
+    readonly version: ReplCommand;
+    readonly execute: ReplCommand;
+    readonly parse: ReplCodeCommand;
+    readonly normalize: ReplCodeCommand;
+    readonly 'normalize*': ReplCodeCommand;
+    readonly dataflow: ReplCodeCommand;
+    readonly 'dataflow*': ReplCodeCommand;
+    readonly dataflowsimple: ReplCodeCommand;
+    readonly 'dataflowsimple*': ReplCodeCommand;
+    readonly controlflow: ReplCodeCommand;
+    readonly 'controlflow*': ReplCodeCommand;
+    readonly controlflowbb: ReplCodeCommand;
+    readonly 'controlflowbb*': ReplCodeCommand;
+    readonly query: ReplCodeCommand;
+    readonly 'query*': ReplCodeCommand;
+};
+export type ReplCommandNames = keyof typeof _commands | keyof typeof scripts;
 /**
  * Retrieve all REPL commands (including those generated from master scripts)
  */
@@ -26,3 +50,4 @@ export declare function longestCommandName(): number;
  * @see {@link longestCommandName}
  */
 export declare function padCmd<T>(string: T): string;
+export {};

package/cli/repl/commands/repl-query.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryStarCommand = exports.queryCommand = void 0;
-const retriever_1 = require("../../../r-bridge/retriever");
-const args_1 = require("../../../util/text/args");
 const ansi_1 = require("../../../util/text/ansi");
 const schema_1 = require("../../../util/schema");
 const query_1 = require("../../../queries/query");
-const json_1 = require("../../../util/json");
+const retriever_1 = require("../../../r-bridge/retriever");
 const query_print_1 = require("../../../queries/query-print");
+const json_1 = require("../../../util/json");
+const args_1 = require("../../../util/text/args");
 function printHelp(output) {
     output.stderr(`Format: ${(0, ansi_1.italic)(':query "<query>" <code>', output.formatter)}`);
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
@@ -45,8 +45,20 @@ async function processQueryArgs(output, analyzer, remainingArgs) {
         }
         const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {
-            output.stderr(`Invalid query: ${validationResult.error.message}`);
-            printHelp(output);
+            output.stderr(`Invalid query: "${output.formatter.format(JSON.stringify(parsedQuery), { style: 3 /* FontStyles.Italic */, color: 3 /* Colors.Yellow */, effect: ansi_1.ColorEffect.Foreground })}"`);
+            for (const line of validationResult.error.details) {
+                const value = line.context?.value ? JSON.stringify(line.context.value) : undefined;
+                output.stderr(` - ${line.message} ${value ? '(' + (0, ansi_1.italic)(value, output.formatter) + ')' : ''}`);
+                const ctx = line.context;
+                for (const detail of ctx?.details?.slice(0, ctx.details.length - 1) ?? []) {
+                    if ('context' in detail && 'message' in detail.context) {
+                        const lines = detail.context.message.split('. ');
+                        for (const l of lines) {
+                            output.stderr(`   - ${l.trim()}`);
+                        }
+                    }
+                }
+            }
             return;
         }
     }

package/cli/wiki.d.ts

@@ -1,3 +1,16 @@
+import { WikiFaq } from '../documentation/wiki-faq';
+import { DocCapabilities, WikiCore, WikiDataflowGraph, WikiEngine, WikiInterface, WikiLintingAndTesting, WikiNormalizedAst, WikiQuery, WikiSearch } from '../documentation';
+import { WikiCfg } from '../documentation/wiki-cfg';
+import { WikiOnboarding } from '../documentation/wiki-onboarding';
+import { WikiAnalyzer } from '../documentation/wiki-analyzer';
+import { IssueLintingRule } from '../documentation/issue-linting-rule';
+import { DocReadme } from '../documentation/doc-readme';
+import { WikiLinter } from '../documentation/wiki-linter';
+import { WikiSetup } from '../documentation/wiki-setup';
+import { WikiOverview } from '../documentation/wiki-overview';
+export declare const AllWikiDocuments: [WikiFaq, WikiSearch, WikiCfg, WikiQuery, WikiOnboarding, WikiAnalyzer, WikiEngine, WikiNormalizedAst, WikiCore, WikiSetup, WikiOverview, WikiInterface, WikiDataflowGraph, WikiLintingAndTesting, WikiLinter, IssueLintingRule, DocReadme, DocCapabilities];
+export type ValidWikiDocumentTargets = ReturnType<typeof AllWikiDocuments[number]['getTarget']>;
+export type ValidWikiDocumentTargetsNoSuffix = ValidWikiDocumentTargets extends `${infer Name}.${string}` ? Name : never;
 /**
  * Updates and optionally re-creates all flowR wikis.
  */

package/cli/wiki.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllWikiDocuments = void 0;
 exports.makeAllWikis = makeAllWikis;
 const doc_context_1 = require("../documentation/wiki-mk/doc-context");
 const shell_1 = require("../r-bridge/shell");
@@ -22,7 +23,9 @@ const issue_linting_rule_1 = require("../documentation/issue-linting-rule");
 const doc_readme_1 = require("../documentation/doc-readme");
 const wiki_linter_1 = require("../documentation/wiki-linter");
 const os_1 = __importDefault(require("os"));
-const Documents = [
+const wiki_setup_1 = require("../documentation/wiki-setup");
+const wiki_overview_1 = require("../documentation/wiki-overview");
+exports.AllWikiDocuments = [
     new wiki_faq_1.WikiFaq(),
     new documentation_1.WikiSearch(),
     new wiki_cfg_1.WikiCfg(),
@@ -32,6 +35,8 @@ const Documents = [
     new documentation_1.WikiEngine(),
     new documentation_1.WikiNormalizedAst(),
     new documentation_1.WikiCore(),
+    new wiki_setup_1.WikiSetup(),
+    new wiki_overview_1.WikiOverview(),
     new documentation_1.WikiInterface(),
     new documentation_1.WikiDataflowGraph(),
     new documentation_1.WikiLintingAndTesting(),
@@ -82,7 +87,7 @@ async function makeAllWikis(force, filter) {
     console.log(`Setup for wiki generation took ${(new Date().getTime() - setupStart.getTime())}ms`);
     const changedWikis = new Set();
     try {
-        const sortedDocs = sortByLeastRecentChanged(Documents);
+        const sortedDocs = sortByLeastRecentChanged(exports.AllWikiDocuments);
         console.log(`Generating ${sortedDocs.length} wikis/docs, sorted by most recently updated...`);
         for (const doc of sortedDocs) {
             const type = doc.getTarget().toLowerCase().includes('wiki') ? 'Wiki' : 'Doc';

package/config.d.ts

@@ -152,6 +152,10 @@ export interface FlowrConfigOptions extends MergeableRecord {
      * Configuration options for abstract interpretation
      */
     readonly abstractInterpretation: {
+        /**
+         * The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration
+         */
+        readonly wideningThreshold: number;
         /**
          * The configuration of the shape inference for data frames
          */
@@ -160,10 +164,6 @@ export interface FlowrConfigOptions extends MergeableRecord {
              * The maximum number of columns names to infer for data frames before over-approximating the column names to top
              */
             readonly maxColNames: number;
-            /**
-             * The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration
-             */
-            readonly wideningThreshold: number;
             /**
              * Configuration options for reading data frame shapes from loaded external data files, such as CSV files
              */

package/config.js

@@ -86,9 +86,9 @@ exports.defaultConfigOptions = {
         }
     },
     abstractInterpretation: {
+        wideningThreshold: 4,
         dataFrame: {
             maxColNames: 50,
-            wideningThreshold: 4,
             readLoadedData: {
                 readExternalFiles: true,
                 maxReadLines: 1e6

package/control-flow/basic-cfg-guided-visitor.js

@@ -30,19 +30,18 @@ class BasicCfgGuidedVisitor {
         return true;
     }
     startVisitor(start) {
-        const g = this.config.controlFlow.graph;
-        const n = this.config.defaultVisitingOrder === 'forward' ?
-            (n) => g.ingoingEdges(n) :
-            (n) => g.outgoingEdges(n);
+        const graph = this.config.controlFlow.graph;
+        const getNext = this.config.defaultVisitingOrder === 'forward' ?
+            (node) => graph.ingoingEdges(node)?.keys().toArray().toReversed() :
+            (node) => graph.outgoingEdges(node)?.keys().toArray();
         const stack = [...start];
         while (stack.length > 0) {
-            const current = stack.shift();
+            const current = stack.pop();
             if (!this.visitNode(current)) {
                 continue;
             }
-            const outgoing = n(current) ?? [];
-            for (const [to] of outgoing) {
-                stack.unshift(to);
+            for (const next of getNext(current) ?? []) {
+                stack.push(next);
             }
         }
     }

package/control-flow/cfg-dead-code.js

@@ -58,7 +58,8 @@ class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.Semant
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            resolve: this.config.ctx.config.solver.variables,
+            ctx: this.config.ctx,
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             this.unableToCalculateValue(id);
@@ -83,7 +84,7 @@ class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.Semant
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            ctx: this.config.ctx,
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             return undefined;

package/control-flow/control-flow-graph.d.ts

@@ -103,7 +103,7 @@ export interface ReadOnlyControlFlowGraph {
     readonly rootIds: () => ReadonlySet<NodeId>;
     /**
      * Provide a view of all vertices in the graph.
-     * @param includeBasicBlockElements - if true, the elements of basic block elements are included in the result, otherwise this will only the basic blocks themselves
+     * @param includeBasicBlockElements - if true, the elements of basic block elements are included in the result, otherwise only the basic blocks themselves are included
      * @see {@link ReadOnlyControlFlowGraph#rootVertexIds|rootVertexIds()} - for a way to get the root vertices of the graph.
      * @see {@link ReadOnlyControlFlowGraph#getVertex|getVertex()} - for a way to get a specific vertex by its id.
      * @see {@link ReadOnlyControlFlowGraph#edges|edges()} - for a way to get all edges in the graph.

package/control-flow/semantic-cfg-guided-visitor.d.ts

@@ -205,7 +205,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow ex
      * @protected
      */
     protected onUnnamedCall(_data: {
-        vertex: DataflowGraphVertexFunctionCall;
+        call: DataflowGraphVertexFunctionCall;
     }): void;
     /**
      * This event triggers for every function call that is not handled by a specific overload,

package/control-flow/semantic-cfg-guided-visitor.js

@@ -115,7 +115,7 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
     visitFunctionCall(vertex) {
         super.visitFunctionCall(vertex);
         if (vertex.origin === 'unnamed') {
-            this.onUnnamedCall({ vertex });
+            this.onUnnamedCall({ call: vertex });
         }
         else {
             this.onDispatchFunctionCallOrigins(vertex, vertex.origin);

package/control-flow/useless-loop.js

@@ -39,7 +39,8 @@ function onlyLoopsOnce(loop, dataflow, controlflow, ast, ctx) {
         const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(vectorOfLoop.nodeId, {
             graph: dataflow,
             idMap: dataflow.idMap,
-            resolve: ctx.config.solver.variables
+            resolve: ctx.config.solver.variables,
+            ctx: ctx
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type !== 'vector' || !(0, r_value_1.isValue)(values.elements[0].elements)) {
             return undefined;
@@ -75,7 +76,8 @@ class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.Seman
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            resolve: this.config.ctx.config.solver.variables,
+            ctx: this.config.ctx
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             return undefined;

package/core/steps/all/static-slicing/00-slice.d.ts

@@ -3,6 +3,7 @@ import { PipelineStepStage } from '../../pipeline-step';
 import type { DataflowInformation } from '../../../../dataflow/info';
 import type { SlicingCriteria } from '../../../../slicing/criterion/parse';
 import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../../project/context/flowr-analyzer-context';
 export interface SliceRequiredInput {
     /** The slicing criterion is only of interest if you actually want to slice the R code */
     readonly criterion: SlicingCriteria;
@@ -10,6 +11,8 @@ export interface SliceRequiredInput {
     readonly threshold?: number;
     /** The direction to slice in. Defaults to backward slicing if unset. */
     readonly direction?: SliceDirection;
+    /** The context of the analysis */
+    readonly context?: ReadOnlyFlowrAnalyzerContext;
 }
 export declare enum SliceDirection {
     Backward = "backward",

package/core/steps/all/static-slicing/00-slice.js

@@ -10,7 +10,8 @@ var SliceDirection;
 })(SliceDirection || (exports.SliceDirection = SliceDirection = {}));
 function processor(results, input) {
     const direction = input.direction ?? SliceDirection.Backward;
-    return (0, static_slicer_1.staticSlice)(results.dataflow, results.normalize, input.criterion, direction, input.threshold);
+    const threshold = input.threshold ?? input.context?.config.solver.slicer?.threshold;
+    return (0, static_slicer_1.staticSlice)(input.context, results.dataflow, results.normalize, input.criterion, direction, threshold);
 }
 exports.STATIC_SLICE = {
     name: 'slice',

package/core/steps/pipeline/default-pipelines.d.ts

@@ -22,6 +22,20 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -39,20 +53,6 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -106,6 +106,20 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -123,20 +137,6 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -190,6 +190,20 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -207,20 +221,6 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {

package/dataflow/cluster.js

@@ -10,13 +10,13 @@ const assert_1 = require("../util/assert");
 function findAllClusters(graph) {
     const clusters = [];
     // we reverse the vertices since dependencies usually point "backwards" from later nodes
-    const notReached = new Set([...graph.vertices(true)].map(([id]) => id).reverse());
+    const notReached = new Set(graph.vertices(true).map(([id]) => id).toArray().reverse());
     while (notReached.size > 0) {
         const [startNode] = notReached;
         notReached.delete(startNode);
         clusters.push({
             startNode: startNode,
-            members: [...makeCluster(graph, startNode, notReached)],
+            members: Array.from(makeCluster(graph, startNode, notReached)),
             hasUnknownSideEffects: graph.unknownSideEffects.has(startNode)
         });
     }

package/dataflow/environments/append.d.ts

@@ -1,4 +1,9 @@
 import { type REnvironmentInformation } from './environment';
+import type { IdentifierDefinition } from './identifier';
+/**
+ * Merges two arrays of identifier definitions, ensuring uniqueness based on `nodeId` and `definedAt`.
+ */
+export declare function uniqueMergeValuesInDefinitions(old: IdentifierDefinition[], value: readonly IdentifierDefinition[]): IdentifierDefinition[];
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */

package/dataflow/environments/append.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueMergeValuesInDefinitions = uniqueMergeValuesInDefinitions;
 exports.appendEnvironment = appendEnvironment;
 const assert_1 = require("../../util/assert");
-const environment_1 = require("./environment");
-function uniqueMergeValues(old, value) {
+/**
+ * Merges two arrays of identifier definitions, ensuring uniqueness based on `nodeId` and `definedAt`.
+ */
+function uniqueMergeValuesInDefinitions(old, value) {
     const result = old;
     for (const v of value) {
         const find = result.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
@@ -13,23 +16,6 @@ function uniqueMergeValues(old, value) {
     }
     return result;
 }
-function appendIEnvironmentWith(base, next) {
-    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not append environments with undefined');
-    const map = new Map(base.memory);
-    for (const [key, value] of next.memory) {
-        const old = map.get(key);
-        if (old) {
-            map.set(key, uniqueMergeValues(old, value));
-        }
-        else {
-            map.set(key, value);
-        }
-    }
-    const parent = base.parent.builtInEnv ? base.parent : appendIEnvironmentWith(base.parent, next.parent);
-    const out = new environment_1.Environment(parent);
-    out.memory = map;
-    return out;
-}
 function appendEnvironment(base, next) {
     if (base === undefined) {
         return next;
@@ -39,7 +25,7 @@ function appendEnvironment(base, next) {
     }
     (0, assert_1.guard)(base.level === next.level, 'environments must have the same level to be handled, it is up to the caller to ensure that');
     return {
-        current: appendIEnvironmentWith(base.current, next.current),
+        current: base.current.append(next.current),
         level: base.level,
     };
 }

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

@@ -33,6 +33,7 @@ import { resolveAsMinus, resolveAsPlus, resolveAsSeq, resolveAsVector } from '..
 import type { DataflowGraph } from '../graph/graph';
 import type { VariableResolve } from '../../config';
 import type { BuiltInConstantDefinition, BuiltInDefinition, BuiltInFunctionDefinition, BuiltInReplacementDefinition } from './built-in-config';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 export type BuiltIn = `built-in:${string}`;
 /**
  * Generate a built-in id for the given name
@@ -69,7 +70,7 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
      */
     readonly useAsProcessor?: UseAsProcessors;
 }
-export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
+export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, 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>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;

package/dataflow/environments/clone.d.ts

@@ -4,4 +4,4 @@ import { type REnvironmentInformation } from './environment';
  * @param environment        - The environment information to clone.
  * @param recurseParents     - Whether to clone the parent environments as well.
  */
-export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;
+export declare function cloneEnvironmentInformation({ current, level }: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;