@eagleoutice/flowr 2.1.12 → 2.2.0

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryStarCommand = exports.queryCommand = void 0;
-const pipeline_executor_1 = require("../../../core/pipeline-executor");
 const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const args_1 = require("../../../util/args");
@@ -10,9 +9,8 @@ const schema_1 = require("../../../util/schema");
 const query_1 = require("../../../queries/query");
 const json_1 = require("../../../util/json");
 const query_print_1 = require("../../../queries/query-print");
-async function getDataflow(shell, remainingLine) {
-    return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
-        shell,
+async function getDataflow(parser, remainingLine) {
+    return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
     }).allRemainingSteps();
 }
@@ -26,7 +24,7 @@ function printHelp(output) {
     output.stdout(`Similarly, '@<type>' is interpreted as a query of the given type.`);
     output.stdout(`With this, ${(0, ansi_1.italic)(':query @config', output.formatter)} prints the result of the config query.`);
 }
-async function processQueryArgs(line, shell, output) {
+async function processQueryArgs(line, parser, output) {
     const args = (0, args_1.splitAtEscapeSensitive)(line);
     const query = args.shift();
     if (!query) {
@@ -59,7 +57,7 @@ async function processQueryArgs(line, shell, output) {
     else {
         parsedQuery = [{ type: 'call-context', callName: query }];
     }
-    const processed = await getDataflow(shell, args.join(' '));
+    const processed = await getDataflow(parser, args.join(' '));
     return {
         query: (0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize }, parsedQuery),
         processed
@@ -70,9 +68,9 @@ exports.queryCommand = {
     usageExample: ':query "<query>" <code>',
     aliases: [],
     script: false,
-    fn: async (output, shell, remainingLine) => {
+    fn: async (output, parser, remainingLine) => {
         const totalStart = Date.now();
-        const results = await processQueryArgs(remainingLine, shell, output);
+        const results = await processQueryArgs(remainingLine, parser, output);
         const totalEnd = Date.now();
         if (results) {
             output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed));

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

@@ -1,5 +1,5 @@
 import type { ReplCommand, ReplOutput } from './repl-main';
-import type { RShell } from '../../../r-bridge/shell';
+import type { KnownParser } from '../../../r-bridge/parser';
 type Version = `${number}.${number}.${number}`;
 /**
  * Describes the version of flowR and the used R interpreter.
@@ -8,9 +8,10 @@ export interface VersionInformation {
     /** The version of flowR */
     flowr: Version;
     /** The version of R identified by the underlying {@link RShell} */
-    r: Version | 'unknown';
+    r: Version | 'unknown' | 'none';
+    engine: string;
 }
-export declare function retrieveVersionInformation(shell: RShell): Promise<VersionInformation>;
-export declare function printVersionInformation(output: ReplOutput, shell: RShell): Promise<void>;
+export declare function retrieveVersionInformation(parser: KnownParser): Promise<VersionInformation>;
+export declare function printVersionInformation(output: ReplOutput, parser: KnownParser): Promise<void>;
 export declare const versionCommand: ReplCommand;
 export {};

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

@@ -6,23 +6,24 @@ exports.printVersionInformation = printVersionInformation;
 const version_1 = require("../../../util/version");
 const assert_1 = require("../../../util/assert");
 const versionRegex = /^\d+\.\d+\.\d+/m;
-async function retrieveVersionInformation(shell) {
+async function retrieveVersionInformation(parser) {
     const flowr = (0, version_1.flowrVersion)().toString();
-    const r = (await shell.usedRVersion())?.format() ?? 'unknown';
+    const r = await parser.rVersion();
     (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
-    (0, assert_1.guard)(r === 'unknown' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
-    return { flowr: flowr, r: r };
+    (0, assert_1.guard)(r === 'unknown' || r === 'none' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
+    return { flowr: flowr, r: r, engine: parser.name };
 }
-async function printVersionInformation(output, shell) {
-    const { flowr, r } = await retrieveVersionInformation(shell);
-    output.stdout(`flowR: ${flowr}`);
-    output.stdout(`R: ${r}`);
+async function printVersionInformation(output, parser) {
+    const { flowr, r, engine } = await retrieveVersionInformation(parser);
+    output.stdout(`Engine: ${engine}`);
+    output.stdout(` flowR: ${flowr}`);
+    output.stdout(` R: ${r}`);
 }
 exports.versionCommand = {
     description: 'Prints the version of flowR as well as the current version of R',
     aliases: [],
     usageExample: ':version',
     script: false,
-    fn: (output, shell) => printVersionInformation(output, shell)
+    fn: (output, parser) => printVersionInformation(output, parser)
 };
 //# sourceMappingURL=repl-version.js.map

package/cli/repl/core.d.ts

@@ -1,7 +1,7 @@
 import * as readline from 'readline';
 import type { ReplOutput } from './commands/repl-main';
-import { RShell } from '../../r-bridge/shell';
 import type { MergeableRecord } from '../../util/objects';
+import type { KnownParser } from '../../r-bridge/parser';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
@@ -12,16 +12,16 @@ export declare const DEFAULT_REPL_READLINE_CONFIGURATION: readline.ReadLineOptio
  *
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
- * @param shell               - The {@link RShell} to use (see {@link repl}).
+ * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-export declare function replProcessAnswer(output: ReplOutput, expr: string, shell: RShell, allowRSessionAccess: boolean): Promise<void>;
+export declare function replProcessAnswer(output: ReplOutput, expr: string, parser: KnownParser, allowRSessionAccess: boolean): Promise<void>;
 /**
  * Options for the {@link repl} function.
  */
 export interface FlowrReplOptions extends MergeableRecord {
     /** The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'. */
-    readonly shell?: RShell;
+    readonly parser?: KnownParser;
     /**
      * A potentially customized readline interface to be used for the repl to *read* from the user, we write the output with the {@link ReplOutput | `output` } interface.
     * If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
@@ -47,5 +47,5 @@ export interface FlowrReplOptions extends MergeableRecord {
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-export declare function repl({ shell, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
+export declare function repl({ parser, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -43,7 +43,6 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const args_1 = require("../../util/args");
-const ansi_1 = require("../../util/ansi");
 const repl_commands_1 = require("./commands/repl-commands");
 const scripts_info_1 = require("../common/scripts-info");
 const retriever_1 = require("../../r-bridge/retriever");
@@ -97,14 +96,14 @@ exports.DEFAULT_REPL_READLINE_CONFIGURATION = {
     removeHistoryDuplicates: true,
     completer: replCompleter
 };
-async function replProcessStatement(output, statement, shell, allowRSessionAccess) {
+async function replProcessStatement(output, statement, parser, allowRSessionAccess) {
     if (statement.startsWith(':')) {
         const command = statement.slice(1).split(' ')[0].toLowerCase();
         const processor = (0, repl_commands_1.getCommand)(command);
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                await processor.fn(output, shell, statement.slice(command.length + 2).trim());
+                await processor.fn(output, parser, statement.slice(command.length + 2).trim(), allowRSessionAccess);
             }
             catch (e) {
                 output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
@@ -114,11 +113,8 @@ async function replProcessStatement(output, statement, shell, allowRSessionAcces
             output.stdout(`the command '${command}' is unknown, try ${bold(':help')} for more information\n`);
         }
     }
-    else if (allowRSessionAccess) {
-        await (0, repl_execute_1.executeRShellCommand)(output, shell, statement);
-    }
     else {
-        output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })}\nIf you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag. Please be careful of the security implications of this action.`);
+        await (0, repl_execute_1.tryExecuteRShellCommand)(output, parser, statement, allowRSessionAccess);
     }
 }
 /**
@@ -126,13 +122,13 @@ async function replProcessStatement(output, statement, shell, allowRSessionAcces
  *
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
- * @param shell               - The {@link RShell} to use (see {@link repl}).
+ * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-async function replProcessAnswer(output, expr, shell, allowRSessionAccess) {
+async function replProcessAnswer(output, expr, parser, allowRSessionAccess) {
     const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
     for (const statement of statements) {
-        await replProcessStatement(output, statement, shell, allowRSessionAccess);
+        await replProcessStatement(output, statement, parser, allowRSessionAccess);
     }
 }
 /**
@@ -147,7 +143,7 @@ async function replProcessAnswer(output, expr, shell, allowRSessionAccess) {
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-async function repl({ shell = new shell_1.RShell({ revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
+async function repl({ parser = new shell_1.RShell({ revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
     if (historyFile) {
         rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
     }
@@ -157,7 +153,7 @@ async function repl({ shell = new shell_1.RShell({ revive: 2 /* RShellReviveOpti
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {
                 rl.pause();
-                replProcessAnswer(output, answer, shell, allowRSessionAccess).then(() => {
+                replProcessAnswer(output, answer, parser, allowRSessionAccess).then(() => {
                     rl.resume();
                     resolve();
                 }).catch(reject);

package/cli/repl/print-version.d.ts

@@ -1,2 +1,2 @@
-import type { RShell } from '../../r-bridge/shell';
-export declare function printVersionRepl(shell: RShell): Promise<void>;
+import type { KnownParser } from '../../r-bridge/parser';
+export declare function printVersionRepl(parser: KnownParser): Promise<void>;

package/cli/repl/print-version.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printVersionRepl = printVersionRepl;
 const repl_version_1 = require("./commands/repl-version");
-async function printVersionRepl(shell) {
-    const version = await (0, repl_version_1.retrieveVersionInformation)(shell);
-    console.log(`flowR repl using flowR ${version.flowr}, R ${version.r}`);
+async function printVersionRepl(parser) {
+    const version = await (0, repl_version_1.retrieveVersionInformation)(parser);
+    console.log(`flowR repl using flowR ${version.flowr}, R ${version.r}, engine ${version.engine}`);
 }
 //# sourceMappingURL=print-version.js.map

package/cli/repl/server/connection.d.ts

@@ -1,20 +1,20 @@
 import type { Socket } from './net';
 import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
-import type { RShell } from '../../../r-bridge/shell';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
+import type { KnownParser } from '../../../r-bridge/parser';
 /**
  * Each connection handles a single client, answering to its requests.
  * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
  */
 export declare class FlowRServerConnection {
     private readonly socket;
-    private readonly shell;
+    private readonly parser;
     private readonly name;
     private readonly logger;
     private readonly allowRSessionAccess;
     private readonly fileMap;
-    constructor(socket: Socket, name: string, shell: RShell, allowRSessionAccess: boolean);
+    constructor(socket: Socket, name: string, parser: KnownParser, allowRSessionAccess: boolean);
     private currentMessageBuffer;
     private handleData;
     private handleFileAnalysisRequest;

package/cli/repl/server/connection.js

@@ -35,7 +35,6 @@ const message_slice_1 = require("./messages/message-slice");
 const server_1 = require("./server");
 const message_repl_1 = require("./messages/message-repl");
 const core_1 = require("../core");
-const pipeline_executor_1 = require("../../../core/pipeline-executor");
 const cfg_1 = require("../../../util/cfg/cfg");
 const quads_1 = require("../../../util/quads");
 const print_1 = require("../../../core/print/print");
@@ -60,16 +59,16 @@ const query_1 = require("../../../queries/query");
  */
 class FlowRServerConnection {
     socket;
-    shell;
+    parser;
     name;
     logger;
     allowRSessionAccess;
     // maps token to information
     fileMap = new Map();
     // we do not have to ensure synchronized shell-access as we are always running synchronized
-    constructor(socket, name, shell, allowRSessionAccess) {
+    constructor(socket, name, parser, allowRSessionAccess) {
         this.socket = socket;
-        this.shell = shell;
+        this.parser = parser;
         this.name = name;
         this.logger = server_1.serverLog.getSubLogger({ name });
         this.socket.on('data', data => this.handleData(String(data)));
@@ -198,8 +197,7 @@ class FlowRServerConnection {
         else {
             throw new Error('Either content or filepath must be defined.');
         }
-        const slicer = new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_SLICING_PIPELINE, {
-            shell: this.shell,
+        const slicer = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
             request,
             criterion: [] // currently unknown
         });
@@ -270,7 +268,7 @@ class FlowRServerConnection {
             formatter: request.ansi ? ansi_1.ansiFormatter : ansi_1.voidFormatter,
             stdout: msg => out('stdout', msg),
             stderr: msg => out('stderr', msg)
-        }, request.expression, this.shell, this.allowRSessionAccess).then(() => {
+        }, request.expression, this.parser, this.allowRSessionAccess).then(() => {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'end-repl-execution',
                 id: request.id

package/cli/repl/server/messages/message-hello.js

@@ -13,7 +13,8 @@ exports.helloMessageDefinition = {
         clientName: joi_1.default.string().required().description('A unique name that is assigned to each client. It has no semantic meaning and is only used/useful for debugging.'),
         versions: joi_1.default.object({
             flowr: joi_1.default.string().required().description('The version of the flowr server running in semver format.'),
-            r: joi_1.default.string().required().description('The version of the underlying R shell running in semver format.')
+            r: joi_1.default.string().required().description('The version of the underlying R shell running in semver format.'),
+            engine: joi_1.default.string().required().description('The parser backend that is used to parse the R code.')
         }).required()
     }).required()
 };

package/cli/repl/server/server.d.ts

@@ -1,6 +1,6 @@
 import type { Server } from './net';
 import { FlowrLogger } from '../../../util/log';
-import type { RShell } from '../../../r-bridge/shell';
+import type { KnownEngines } from '../../../config';
 export declare const serverLog: FlowrLogger;
 /**
  * This class controls the TCP server, which can be started by calling {@link start}.
@@ -9,13 +9,14 @@ export declare const serverLog: FlowrLogger;
  */
 export declare class FlowRServer {
     private readonly server;
-    private readonly shell;
+    private readonly engines;
+    private readonly defaultEngine;
     private versionInformation;
     private readonly allowRSessionAccess;
     /** maps names to the respective connection */
     private readonly connections;
     private nameCounter;
-    constructor(shell: RShell, allowRSessionAccess: boolean, server?: Server);
+    constructor(engines: KnownEngines, defaultEngine: keyof KnownEngines, allowRSessionAccess: boolean, server?: Server);
     start(port: number): Promise<void>;
     private onConnect;
 }

package/cli/repl/server/server.js

@@ -15,20 +15,22 @@ exports.serverLog = new log_1.FlowrLogger({ name: 'server' });
  */
 class FlowRServer {
     server;
-    shell;
+    engines;
+    defaultEngine;
     versionInformation;
     allowRSessionAccess;
     /** maps names to the respective connection */
     connections = new Map();
     nameCounter = 0;
-    constructor(shell, allowRSessionAccess, server = new net_1.NetServer()) {
+    constructor(engines, defaultEngine, allowRSessionAccess, server = new net_1.NetServer()) {
         this.server = server;
         this.server.onConnect(c => this.onConnect(c));
-        this.shell = shell;
+        this.engines = engines;
+        this.defaultEngine = defaultEngine;
         this.allowRSessionAccess = allowRSessionAccess;
     }
     async start(port) {
-        this.versionInformation = await (0, repl_version_1.retrieveVersionInformation)(this.shell);
+        this.versionInformation = await (0, repl_version_1.retrieveVersionInformation)(this.engines[this.defaultEngine]);
         this.server.start(port);
         exports.serverLog.info(`Server listening on port ${port}`);
     }
@@ -39,7 +41,7 @@ class FlowRServer {
         }
         const name = `client-${this.nameCounter++}`;
         exports.serverLog.info(`Client connected: ${(0, send_1.getUnnamedSocketName)(c)} as "${name}"`);
-        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.shell, this.allowRSessionAccess));
+        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.engines[this.defaultEngine], this.allowRSessionAccess));
         helloClient(c, name, this.versionInformation);
         c.on('close', () => {
             this.connections.delete(name);

package/cli/slicer-app.js

@@ -25,7 +25,7 @@ const options = (0, script_1.processCommandLineArgs)('slicer', ['input', 'criter
     ]
 });
 async function getSlice() {
-    const slicer = new slicer_1.BenchmarkSlicer();
+    const slicer = new slicer_1.BenchmarkSlicer('r-shell');
     (0, assert_1.guard)(options.input !== undefined, 'input must be given');
     (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
     await slicer.init(options['input-is-text']

package/config.d.ts

@@ -1,6 +1,7 @@
 import type { MergeableRecord } from './util/objects';
 import Joi from 'joi';
 import type { BuiltInDefinitions } from './dataflow/environments/built-in-config';
+import type { KnownParser } from './r-bridge/parser';
 export declare enum VariableResolve {
     /** Don't resolve constants at all */
     Disabled = "disabled",
@@ -14,10 +15,6 @@ export interface FlowrConfigOptions extends MergeableRecord {
      * Whether source calls should be ignored, causing {@link processSourceCall}'s behavior to be skipped
      */
     readonly ignoreSourceCalls: boolean;
-    /**
-     * The path to the R executable to use. If this is undefined, {@link DEFAULT_R_PATH} will be used.
-     */
-    readonly rPath: string | undefined;
     /** Configure language semantics and how flowR handles them */
     readonly semantics: {
         /** Semantics regarding the handlings of the environment */
@@ -31,6 +28,15 @@ export interface FlowrConfigOptions extends MergeableRecord {
             };
         };
     };
+    /**
+     * The engines to use for interacting with R code. Currently supports {@link TreeSitterEngineConfig} and {@link RShellEngineConfig}.
+     * An empty array means all available engines will be used.
+     */
+    readonly engines: readonly EngineConfig[];
+    /**
+     * The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from {@link engines} will be used.
+     */
+    readonly defaultEngine?: EngineConfig['type'];
     /** How to resolve constants, constraints, cells, ... */
     readonly solver: {
         /**
@@ -45,9 +51,35 @@ export interface FlowrConfigOptions extends MergeableRecord {
         readonly pointerTracking: boolean;
     };
 }
+export interface TreeSitterEngineConfig extends MergeableRecord {
+    readonly type: 'tree-sitter';
+    /**
+     * The path to the tree-sitter-r WASM binary to use. If this is undefined, {@link DEFAULT_TREE_SITTER_R_WASM_PATH} will be used.
+     */
+    readonly wasmPath?: string;
+    /**
+     * The path to the tree-sitter WASM binary to use. If this is undefined, the path specified by the tree-sitter package will be used.
+     */
+    readonly treeSitterWasmPath?: string;
+}
+export interface RShellEngineConfig extends MergeableRecord {
+    readonly type: 'r-shell';
+    /**
+     * The path to the R executable to use. If this is undefined, {@link DEFAULT_R_PATH} will be used.
+     */
+    readonly rPath?: string;
+}
+export type EngineConfig = TreeSitterEngineConfig | RShellEngineConfig;
+export type KnownEngines = {
+    [T in EngineConfig['type']]?: KnownParser;
+};
 export declare const defaultConfigOptions: FlowrConfigOptions;
 export declare const flowrConfigFileSchema: Joi.ObjectSchema<any>;
 export declare function setConfigFile(file: string | undefined, workingDirectory?: string, forceLoad?: boolean): void;
 export declare function parseConfig(jsonString: string): FlowrConfigOptions | undefined;
 export declare function setConfig(config: FlowrConfigOptions): void;
+export declare function amendConfig(amendment: Partial<FlowrConfigOptions>): void;
 export declare function getConfig(): FlowrConfigOptions;
+export declare function getEngineConfig<T extends EngineConfig['type']>(engine: T): EngineConfig & {
+    type: T;
+} | undefined;

package/config.js

@@ -7,7 +7,9 @@ exports.flowrConfigFileSchema = exports.defaultConfigOptions = exports.VariableR
 exports.setConfigFile = setConfigFile;
 exports.parseConfig = parseConfig;
 exports.setConfig = setConfig;
+exports.amendConfig = amendConfig;
 exports.getConfig = getConfig;
+exports.getEngineConfig = getEngineConfig;
 const objects_1 = require("./util/objects");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -23,6 +25,10 @@ var VariableResolve;
     /** Only resolve directly assigned builtin constants */
     VariableResolve["Builtin"] = "builtin";
 })(VariableResolve || (exports.VariableResolve = VariableResolve = {}));
+const defaultEngineConfigs = {
+    'tree-sitter': { type: 'tree-sitter' },
+    'r-shell': { type: 'r-shell' }
+};
 exports.defaultConfigOptions = {
     ignoreSourceCalls: false,
     rPath: undefined,
@@ -34,6 +40,8 @@ exports.defaultConfigOptions = {
             }
         }
     },
+    engines: [],
+    defaultEngine: 'r-shell',
     solver: {
         variables: VariableResolve.Alias,
         pointerTracking: true
@@ -41,7 +49,6 @@ exports.defaultConfigOptions = {
 };
 exports.flowrConfigFileSchema = joi_1.default.object({
     ignoreSourceCalls: joi_1.default.boolean().optional().description('Whether source calls should be ignored, causing {@link processSourceCall}\'s behavior to be skipped.'),
-    rPath: joi_1.default.string().optional().description('The path to the R executable to use. If this is undefined, this uses the default path.'),
     semantics: joi_1.default.object({
         environment: joi_1.default.object({
             overwriteBuiltIns: joi_1.default.object({
@@ -50,6 +57,15 @@ exports.flowrConfigFileSchema = joi_1.default.object({
             }).optional().description('Do you want to overwrite (parts) of the builtin definition?')
         }).optional().description('Semantics regarding the handlings of the environment.')
     }).description('Configure language semantics and how flowR handles them.'),
+    engines: joi_1.default.array().items(joi_1.default.alternatives(joi_1.default.object({
+        type: joi_1.default.string().required().valid('tree-sitter').description('Use the tree sitter engine.'),
+        wasmPath: joi_1.default.string().optional().description('The path to the tree-sitter-r WASM binary to use. If this is undefined, this uses the default path.'),
+        treeSitterWasmPath: joi_1.default.string().optional().description('The path to the tree-sitter WASM binary to use. If this is undefined, this uses the default path.')
+    }).description('The configuration for the tree sitter engine.'), joi_1.default.object({
+        type: joi_1.default.string().required().valid('r-shell').description('Use the R shell engine.'),
+        rPath: joi_1.default.string().optional().description('The path to the R executable to use. If this is undefined, this uses the default path.')
+    }).description('The configuration for the R shell engine.'))).min(1).description('The engine or set of engines to use for interacting with R code. An empty array means all available engines will be used.'),
+    defaultEngine: joi_1.default.string().optional().valid('tree-sitter', 'r-shell').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.'),
     solver: joi_1.default.object({
         variables: joi_1.default.string().valid(...Object.values(VariableResolve)).description('How to resolve variables and their values.'),
         pointerTracking: joi_1.default.boolean().description('Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses.')
@@ -88,6 +104,10 @@ function parseConfig(jsonString) {
 function setConfig(config) {
     currentConfig = config;
 }
+function amendConfig(amendment) {
+    setConfig((0, objects_1.deepMergeObject)(getConfig(), amendment));
+    log_1.log.trace(`Amending config with ${JSON.stringify(amendment)}, resulting in ${JSON.stringify(getConfig())}}`);
+}
 function getConfig() {
     // lazy-load the config based on the current settings
     if (currentConfig === undefined) {
@@ -95,6 +115,15 @@ function getConfig() {
     }
     return currentConfig;
 }
+function getEngineConfig(engine) {
+    const config = getConfig().engines;
+    if (!config.length) {
+        return defaultEngineConfigs[engine];
+    }
+    else {
+        return config.find(e => e.type == engine);
+    }
+}
 function loadConfigFromFile(configFile, workingDirectory) {
     if (configFile !== undefined) {
         let searchPath = path_1.default.resolve(workingDirectory);

package/core/pipeline-executor.d.ts

@@ -61,7 +61,7 @@ import type { Pipeline, PipelineInput, PipelineOutput, PipelinePerRequestInput,
  *
  * ```ts
  * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
- *    shell:     new RShell(),
+ *    parser:    new RShell(),
  *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
  *    criterion: ['2@b'],
  *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),

package/core/pipeline-executor.js

@@ -65,7 +65,7 @@ const built_in_config_1 = require("../dataflow/environments/built-in-config");
  *
  * ```ts
  * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
- *    shell:     new RShell(),
+ *    parser:    new RShell(),
  *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
  *    criterion: ['2@b'],
  *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),

package/core/steps/all/core/00-parse.d.ts

@@ -1,25 +1,12 @@
 import { internalPrinter } from '../../../print/print';
 import { PipelineStepStage } from '../../pipeline-step';
-import type { RShellExecutor } from '../../../../r-bridge/shell-executor';
-import type { RShell } from '../../../../r-bridge/shell';
-import type { RParseRequests } from '../../../../r-bridge/retriever';
 import type { QuadSerializationConfiguration } from '../../../../util/quads';
-export interface ParseRequiredInput {
-    /** This is the {@link RShell} or {@link RShellExecutor} connection to be used to obtain the original parses AST of the R code */
-    readonly shell: RShell | RShellExecutor;
-    /** The request which essentially indicates the input to extract the AST from */
-    readonly request: RParseRequests;
-}
-export interface ParseStepOutput {
-    /** The parsed AST of the R code as given by the R parse side */
-    readonly parsed: string;
-}
-declare function processor(_results: unknown, input: Partial<ParseRequiredInput>): Promise<ParseStepOutput>;
+import type { ParseRequiredInput } from '../../../../r-bridge/parser';
 export declare const PARSE_WITH_R_SHELL_STEP: {
     readonly name: "parse";
     readonly humanReadableName: "parse with R shell";
     readonly description: "Parse the given R code into an AST";
-    readonly processor: typeof processor;
+    readonly processor: (_results: unknown, input: Partial<ParseRequiredInput<string>>) => Promise<import("../../../../r-bridge/parser").ParseStepOutput<string>>;
     readonly executed: PipelineStepStage.OncePerFile;
     readonly printer: {
         readonly 0: typeof internalPrinter;
@@ -27,9 +14,8 @@ export declare const PARSE_WITH_R_SHELL_STEP: {
             (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
             (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
         };
-        readonly 5: ({ parsed }: ParseStepOutput, config: QuadSerializationConfiguration) => string;
+        readonly 5: ({ parsed }: import("../../../../r-bridge/parser").ParseStepOutput<string>, config: QuadSerializationConfiguration) => string;
     };
     readonly dependencies: readonly [];
-    readonly requiredInput: ParseRequiredInput;
+    readonly requiredInput: ParseRequiredInput<string>;
 };
-export {};

package/core/steps/all/core/00-parse.js

@@ -3,21 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PARSE_WITH_R_SHELL_STEP = void 0;
 const print_1 = require("../../../print/print");
 const parse_printer_1 = require("../../../print/parse-printer");
-const retriever_1 = require("../../../../r-bridge/retriever");
-async function processor(_results, input) {
-    /* in the future, we want to expose all cases */
-    if (Array.isArray(input.request)) {
-        return { parsed: await (0, retriever_1.retrieveParseDataFromRCode)(input.request[0], input.shell) };
-    }
-    else {
-        return { parsed: await (0, retriever_1.retrieveParseDataFromRCode)(input.request, input.shell) };
-    }
-}
+const parser_1 = require("../../../../r-bridge/parser");
 exports.PARSE_WITH_R_SHELL_STEP = {
     name: 'parse',
     humanReadableName: 'parse with R shell',
     description: 'Parse the given R code into an AST',
-    processor,
+    processor: (parser_1.parseRequests),
     executed: 0 /* PipelineStepStage.OncePerFile */,
     printer: {
         [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,