@eagleoutice/flowr 2.5.0 → 2.6.0

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

@@ -1,6 +1,7 @@
 import type { OutputFormatter } from '../../../util/text/ansi';
 import type { KnownParser } from '../../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../../config';
+import type { FlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 /**
  * Defines the main interface for output of the repl.
  * This allows us to redirect it (e.g., in the case of a server connection or tests).
@@ -20,20 +21,29 @@ export interface ReplOutput {
  */
 export declare const standardReplOutput: ReplOutput;
 /**
- * Information passed to each repl command function
+ * Information passed to each {@link ReplCommand#fn}.
  */
 export interface ReplCommandInformation {
     output: ReplOutput;
+    allowRSessionAccess: boolean;
     parser: KnownParser;
     remainingLine: string;
-    allowRSessionAccess: boolean;
     config: FlowrConfigOptions;
 }
+/**
+ * Information passed to each {@link ReplCodeCommand#fn}.
+ * The {@link analyzer} has the {@link RParseRequest}.
+ */
+export interface ReplCodeCommandInformation {
+    output: ReplOutput;
+    analyzer: FlowrAnalysisProvider;
+    remainingArgs: string[];
+}
 /**
  * Content of a single command in the repl.
  * The command may execute an external script or simply call *flowR* functions.
  */
-export interface ReplCommand {
+export interface ReplBaseCommand {
     /** Aliases of the command (without the leading colon), every alias must be unique (this is checked at runtime) */
     aliases: string[];
     /** A human-readable description of what the command does */
@@ -42,9 +52,30 @@ export interface ReplCommand {
     script: boolean;
     /** Example of how to use the command, for example `:slicer --help` */
     usageExample: string;
+}
+export interface ReplCommand extends ReplBaseCommand {
+    usesAnalyzer: false;
     /**
      * Function to execute when the command is invoked, it must not write to the command line but instead use the output handler.
      * Furthermore, it has to obey the formatter defined in the {@link ReplOutput}.
      */
     fn: (info: ReplCommandInformation) => Promise<void> | void;
 }
+/**
+ * Repl command that uses the {@link FlowrAnalyzer}
+ */
+export interface ReplCodeCommand extends ReplBaseCommand {
+    usesAnalyzer: true;
+    /**
+     * Function to execute when the command is invoked, it must not write to the command line but instead use the output handler.
+     * Furthermore, it has to obey the formatter defined in the {@link ReplOutput}.
+     */
+    fn: (info: ReplCodeCommandInformation) => Promise<void> | void;
+    /**
+     * Argument parser function which handles the input given after the repl command
+     */
+    argsParser: (remainingLine: string) => {
+        input: string;
+        remaining: string[];
+    };
+}

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

@@ -1,3 +1,3 @@
-import type { ReplCommand } from './repl-main';
-export declare const normalizeCommand: ReplCommand;
-export declare const normalizeStarCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const normalizeCommand: ReplCodeCommand;
+export declare const normalizeStarCommand: ReplCodeCommand;

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

@@ -34,51 +34,47 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeStarCommand = exports.normalizeCommand = void 0;
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const ast_1 = require("../../../util/mermaid/ast");
 const ansi_1 = require("../../../util/text/ansi");
-async function normalize(parser, remainingLine, config) {
-    return await (0, default_pipelines_1.createNormalizePipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }, config).allRemainingSteps();
-}
-function handleString(code) {
-    return code.startsWith('"') ? JSON.parse(code) : code;
-}
-function formatInfo(out, type, timing) {
-    return out.formatter.format(`Copied ${type} to clipboard (normalize: ${timing}ms).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
+const core_1 = require("../core");
+function formatInfo(out, type, meta) {
+    return out.formatter.format(`Copied ${type} to clipboard (normalize: ${meta['.meta'].timing + 'ms'}).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
 }
 exports.normalizeCommand = {
     description: `Get mermaid code for the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':normalize',
     aliases: ['n'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await normalize(parser, handleString(remainingLine), config);
-        const mermaid = (0, ast_1.normalizedAstToMermaid)(result.normalize.ast);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.normalize();
+        const mermaid = (0, ast_1.normalizedAstToMermaid)(result.ast);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.normalize['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }
 };
 exports.normalizeStarCommand = {
     description: 'Returns the URL to mermaid.live',
+    usesAnalyzer: true,
     usageExample: ':normalize*',
     aliases: ['n*'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await normalize(parser, handleString(remainingLine), config);
-        const mermaid = (0, ast_1.normalizedAstToMermaidUrl)(result.normalize.ast);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.normalize();
+        const mermaid = (0, ast_1.normalizedAstToMermaidUrl)(result.ast);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.normalize['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }

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

@@ -1,2 +1,2 @@
-import type { ReplCommand } from './repl-main';
-export declare const parseCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const parseCommand: ReplCodeCommand;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCommand = void 0;
 const format_1 = require("../../../r-bridge/lang-4.x/ast/parser/json/format");
 const normalize_meta_1 = require("../../../r-bridge/lang-4.x/ast/parser/main/normalize-meta");
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 function toDepthMap(entry) {
     const visit = [{ depth: 0, node: entry }];
@@ -127,20 +126,26 @@ function depthListToTextTree(list, f) {
 }
 exports.parseCommand = {
     description: `Prints ASCII Art of the parsed, unmodified AST, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':parse',
     aliases: ['p'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await (0, default_pipelines_1.createParsePipeline)(parser, {
-            request: (0, retriever_1.requestFromInput)((0, retriever_1.removeRQuotes)(remainingLine.trim()))
-        }, config).allRemainingSteps();
-        if (parser.name === 'r-shell') {
-            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse.parsed));
+    argsParser: (line) => {
+        return {
+            // Threat the whole input line as R code
+            input: (0, retriever_1.removeRQuotes)(line.trim()),
+            remaining: []
+        };
+    },
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.parse();
+        if (analyzer.parserName() === 'r-shell') {
+            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parsed));
             output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
         }
         else {
             // print the tree-sitter ast
-            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parse.parsed.rootNode), output.formatter));
+            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parsed.rootNode), output.formatter));
         }
     }
 };

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

@@ -1,3 +1,3 @@
-import type { ReplCommand } from './repl-main';
-export declare const queryCommand: ReplCommand;
-export declare const queryStarCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const queryCommand: ReplCodeCommand;
+export declare const queryStarCommand: ReplCodeCommand;

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 default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const args_1 = require("../../../util/text/args");
 const ansi_1 = require("../../../util/text/ansi");
@@ -9,11 +8,6 @@ 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(config, parser, remainingLine) {
-    return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }, config).allRemainingSteps();
-}
 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:');
@@ -24,9 +18,8 @@ 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, parser, output, config) {
-    const args = (0, args_1.splitAtEscapeSensitive)(line);
-    const query = args.shift();
+async function processQueryArgs(output, analyzer, remainingArgs) {
+    const query = remainingArgs.shift();
     if (!query) {
         output.stderr('No query provided, use \':query help\' to get more information.');
         return;
@@ -35,12 +28,12 @@ async function processQueryArgs(line, parser, output, config) {
         printHelp(output);
         return;
     }
-    let parsedQuery = [];
+    let parsedQuery;
     if (query.startsWith('@')) {
         const queryName = query.slice(1);
         const queryObj = query_1.SupportedQueries[queryName];
         if (queryObj?.fromLine) {
-            const q = queryObj.fromLine(args, config);
+            const q = queryObj.fromLine(remainingArgs, analyzer.flowrConfig);
             parsedQuery = q ? (Array.isArray(q) ? q : [q]) : [];
         }
         else {
@@ -65,34 +58,51 @@ async function processQueryArgs(line, parser, output, config) {
     else {
         parsedQuery = [{ type: 'call-context', callName: query }];
     }
-    const processed = await getDataflow(config, parser, args.join(' '));
     return {
+        query: await (0, query_1.executeQueries)({
+            analyzer,
+        }, parsedQuery),
         parsedQuery,
-        query: await Promise.resolve((0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize, config }, parsedQuery)),
-        processed
+        analyzer
+    };
+}
+/**
+ * Function for splitting the input line.
+ * The first token is the query command.
+ * The rest of the line is treated as input code.
+ */
+function parseArgs(line) {
+    const args = (0, args_1.splitAtEscapeSensitive)(line);
+    return {
+        input: args.join(' ').trim(),
+        remaining: args
     };
 }
 exports.queryCommand = {
     description: `Query the given R code, start with '${retriever_1.fileProtocol}' to indicate a file. The query is to be a valid query in json format (use 'help' to get more information).`,
+    usesAnalyzer: true,
     usageExample: ':query "<query>" <code>',
     aliases: [],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
+    argsParser: parseArgs,
+    fn: async ({ output, analyzer, remainingArgs }) => {
         const totalStart = Date.now();
-        const results = await processQueryArgs(remainingLine, parser, output, config);
+        const results = await processQueryArgs(output, analyzer, remainingArgs);
         const totalEnd = Date.now();
         if (results) {
-            output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed, results.parsedQuery));
+            output.stdout(await (0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.analyzer, results.parsedQuery));
         }
     }
 };
 exports.queryStarCommand = {
     description: 'Similar to query, but returns the output in json format.',
+    usesAnalyzer: true,
     usageExample: ':query* <query> <code>',
     aliases: [],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const results = await processQueryArgs(remainingLine, parser, output, config);
+    argsParser: parseArgs,
+    fn: async ({ output, analyzer, remainingArgs }) => {
+        const results = await processQueryArgs(output, analyzer, remainingArgs);
         if (results) {
             output.stdout(JSON.stringify(results.query, json_1.jsonReplacer));
         }

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

@@ -4,6 +4,7 @@ exports.quitCommand = void 0;
 const log_1 = require("../../../util/log");
 exports.quitCommand = {
     description: 'End the repl',
+    usesAnalyzer: false,
     aliases: ['q', 'exit'],
     usageExample: ':quit',
     script: false,

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

@@ -21,6 +21,7 @@ async function printVersionInformation(output, parser) {
 }
 exports.versionCommand = {
     description: 'Prints the version of flowR as well as the current version of R',
+    usesAnalyzer: false,
     aliases: [],
     usageExample: ':version',
     script: false,

package/cli/repl/core.d.ts

@@ -8,6 +8,10 @@ import type { FlowrConfigOptions } from '../../config';
  */
 export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
 export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
+export declare function handleString(code: string): {
+    input: string;
+    remaining: never[];
+};
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
@@ -27,7 +31,6 @@ export interface FlowrReplOptions extends MergeableRecord {
     /**
      * 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}.
-    * For the default arguments, see {@link DEFAULT_REPL_READLINE_CONFIGURATION}.
      */
     readonly rl?: readline.Interface;
     /** Defines two methods that every function in the repl uses to output its data. */

package/cli/repl/core.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replCompleter = replCompleter;
 exports.makeDefaultReplReadline = makeDefaultReplReadline;
+exports.handleString = handleString;
 exports.replProcessAnswer = replProcessAnswer;
 exports.repl = repl;
 exports.loadReplHistory = loadReplHistory;
@@ -61,6 +62,7 @@ const shell_1 = require("../../r-bridge/shell");
 const log_1 = require("../../util/log");
 const config_1 = require("../../config");
 const query_1 = require("../../queries/query");
+const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -129,6 +131,12 @@ function makeDefaultReplReadline(config) {
         completer: (c) => replCompleter(c, config)
     };
 }
+function handleString(code) {
+    return {
+        input: code.startsWith('"') ? JSON.parse(code) : code,
+        remaining: []
+    };
+}
 async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
     if (statement.startsWith(':')) {
         const command = statement.slice(1).split(' ')[0].toLowerCase();
@@ -136,7 +144,19 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                await processor.fn({ output, parser, remainingLine: statement.slice(command.length + 2).trim(), allowRSessionAccess, config });
+                const remainingLine = statement.slice(command.length + 2).trim();
+                if (processor.usesAnalyzer) {
+                    const args = processor.argsParser(remainingLine);
+                    const request = (0, retriever_1.requestFromInput)(args.input);
+                    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
+                        .setConfig(config)
+                        .setParser(parser)
+                        .build();
+                    await processor.fn({ output, analyzer, remainingArgs: args.remaining });
+                }
+                else {
+                    await processor.fn({ output, parser, remainingLine, allowRSessionAccess, config });
+                }
             }
             catch (e) {
                 output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);

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

@@ -1,9 +1,13 @@
 import type { Socket } from './net';
+import type { TREE_SITTER_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
-import type { KnownParser } from '../../../r-bridge/parser';
+import type { KnownParser, ParseStepOutput } from '../../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../../config';
+import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowInformation } from '../../../dataflow/info';
+import type { Tree } from 'web-tree-sitter';
 /**
  * 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.
@@ -21,10 +25,10 @@ export declare class FlowRServerConnection {
     private handleData;
     private handleFileAnalysisRequest;
     private sendFileAnalysisResponse;
-    private createPipelineExecutorForRequest;
+    private createAnalyzerForRequest;
     private handleSliceRequest;
     private handleRepl;
     private handleLineageRequest;
     private handleQueryRequest;
 }
-export declare function sanitizeAnalysisResults(results: Partial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>;
+export declare function sanitizeAnalysisResults(parse: ParseStepOutput<string | Tree>, normalize: NormalizedAst, dataflow: DataflowInformation): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE | typeof TREE_SITTER_DATAFLOW_PIPELINE>>;

package/cli/repl/server/connection.js

@@ -48,20 +48,20 @@ const core_1 = require("../core");
 const extract_cfg_1 = require("../../../control-flow/extract-cfg");
 const quads_1 = require("../../../util/quads");
 const print_1 = require("../../../core/print/print");
+const _00_parse_1 = require("../../../core/steps/all/core/00-parse");
+const _10_normalize_1 = require("../../../core/steps/all/core/10-normalize");
+const _20_dataflow_1 = require("../../../core/steps/all/core/20-dataflow");
 const ansi_1 = require("../../../util/text/ansi");
 const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const graph_1 = require("../../../dataflow/graph/graph");
 const tmp = __importStar(require("tmp"));
 const fs_1 = __importDefault(require("fs"));
-const magic_comments_1 = require("../../../reconstruct/auto-select/magic-comments");
 const message_lineage_1 = require("./messages/message-lineage");
 const repl_lineage_1 = require("../commands/repl-lineage");
-const assert_1 = require("../../../util/assert");
-const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-select-defaults");
 const message_query_1 = require("./messages/message-query");
-const query_1 = require("../../../queries/query");
 const compact_1 = require("./compact");
 const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
+const flowr_analyzer_builder_1 = require("../../../project/flowr-analyzer-builder");
 /**
  * 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.
@@ -117,7 +117,7 @@ class FlowRServerConnection {
                 this.handleRepl(request.message);
                 break;
             case 'request-lineage':
-                this.handleLineageRequest(request.message);
+                void this.handleLineageRequest(request.message);
                 break;
             case 'request-query':
                 this.handleQueryRequest(request.message);
@@ -146,9 +146,11 @@ class FlowRServerConnection {
             this.fileMap.delete(message.filetoken);
         }
         const tempFile = tmp.fileSync({ postfix: '.R' });
-        const slicer = this.createPipelineExecutorForRequest(message, tempFile.name);
-        await slicer.allRemainingSteps(false).then(async (results) => await this.sendFileAnalysisResponse(slicer, results, message))
-            .catch(e => {
+        const analyzer = await this.createAnalyzerForRequest(message, tempFile.name);
+        try {
+            await this.sendFileAnalysisResponse(analyzer, message);
+        }
+        catch (e) {
             this.logger.error(`[${this.name}] Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`);
             (0, send_1.sendMessage)(this.socket, {
                 id: message.id,
@@ -156,22 +158,17 @@ class FlowRServerConnection {
                 fatal: false,
                 reason: `Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`
             });
-        });
+        }
         // this is an interestingly named function that means "I am a callback that removes a file" - so this deletes the file
         tempFile.removeCallback();
     }
-    async sendFileAnalysisResponse(slicer, results, message) {
+    async sendFileAnalysisResponse(analyzer, message) {
         let cfg = undefined;
         if (message.cfg) {
-            cfg = (0, extract_cfg_1.extractCfg)(results.normalize, this.config, results.dataflow?.graph);
+            cfg = await analyzer.controlflow();
         }
         const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
-        const sanitizedResults = sanitizeAnalysisResults(results);
-        const pipeline = slicer.getPipeline();
-        const parseStep = pipeline.steps.get('parse');
-        const normalizedStep = pipeline.steps.get('normalize');
-        const dataflowStep = pipeline.steps.get('dataflow');
-        (0, assert_1.guard)(parseStep !== undefined && normalizedStep !== undefined && dataflowStep !== undefined, 'All steps must be present');
+        const sanitizedResults = sanitizeAnalysisResults(await analyzer.parse(), await analyzer.normalize(), await analyzer.dataflow());
         if (message.format === 'n-quads') {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'response-file-analysis',
@@ -179,9 +176,9 @@ class FlowRServerConnection {
                 id: message.id,
                 cfg: cfg ? (0, extract_cfg_1.cfg2quads)(cfg, config()) : undefined,
                 results: {
-                    parse: await (0, print_1.printStepResult)(parseStep, sanitizedResults.parse, 5 /* StepOutputFormat.RdfQuads */, config()),
-                    normalize: await (0, print_1.printStepResult)(normalizedStep, sanitizedResults.normalize, 5 /* StepOutputFormat.RdfQuads */, config()),
-                    dataflow: await (0, print_1.printStepResult)(dataflowStep, sanitizedResults.dataflow, 5 /* StepOutputFormat.RdfQuads */, config())
+                    parse: await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, await analyzer.parse(), 5 /* StepOutputFormat.RdfQuads */, config()),
+                    normalize: await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, await analyzer.normalize(), 5 /* StepOutputFormat.RdfQuads */, config()),
+                    dataflow: await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, await analyzer.dataflow(), 5 /* StepOutputFormat.RdfQuads */, config())
                 }
             });
         }
@@ -204,7 +201,7 @@ class FlowRServerConnection {
             });
         }
     }
-    createPipelineExecutorForRequest(message, tempFile) {
+    async createAnalyzerForRequest(message, tempFile) {
         let request;
         if (message.content !== undefined) {
             // we store the code in a temporary file in case it's too big for the shell to handle
@@ -222,18 +219,18 @@ class FlowRServerConnection {
         else {
             throw new Error('Either content or filepath must be defined.');
         }
-        const slicer = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
-            request,
-            criterion: [] // currently unknown
-        }, this.config);
+        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
+            .setConfig(this.config)
+            .setParser(this.parser)
+            .build();
         if (message.filetoken) {
             this.logger.info(`Storing file token ${message.filetoken}`);
             this.fileMap.set(message.filetoken, {
                 filename: message.filename,
-                pipeline: slicer
+                analyzer: analyzer
             });
         }
-        return slicer;
+        return analyzer;
     }
     handleSliceRequest(base) {
         const requestResult = (0, validate_1.validateMessage)(base, message_slice_1.requestSliceMessage);
@@ -253,16 +250,16 @@ class FlowRServerConnection {
             });
             return;
         }
-        fileInformation.pipeline.updateRequest({
-            criterion: request.criterion,
-            direction: request.direction,
-            autoSelectIf: request.noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect)
-        });
-        void fileInformation.pipeline.allRemainingSteps(true).then(results => {
+        void fileInformation.analyzer.query([{
+                type: 'static-slice',
+                criteria: request.criterion,
+                noMagicComments: request.noMagicComments,
+                direction: request.direction
+            }]).then(result => {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'response-slice',
                 id: request.id,
-                results: Object.fromEntries(Object.entries(results)
+                results: Object.fromEntries(Object.entries(result)
                     .filter(([k,]) => default_pipelines_1.DEFAULT_SLICING_PIPELINE.steps.get(k)?.executed === 1 /* PipelineStepStage.OncePerRequest */))
             });
         }).catch(e => {
@@ -301,7 +298,7 @@ class FlowRServerConnection {
             });
         });
     }
-    handleLineageRequest(base) {
+    async handleLineageRequest(base) {
         const requestResult = (0, validate_1.validateMessage)(base, message_lineage_1.requestLineageMessage);
         if (requestResult.type === 'error') {
             (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
@@ -319,10 +316,8 @@ class FlowRServerConnection {
             });
             return;
         }
-        const { dataflow: dfg, normalize: ast } = fileInformation.pipeline.getResults(true);
-        (0, assert_1.guard)(dfg !== undefined, `Dataflow graph must be present (request: ${request.filetoken})`);
-        (0, assert_1.guard)(ast !== undefined, `AST must be present (request: ${request.filetoken})`);
-        const lineageIds = (0, repl_lineage_1.getLineage)(request.criterion, dfg.graph, ast.idMap);
+        const analyzer = fileInformation.analyzer;
+        const lineageIds = (0, repl_lineage_1.getLineage)(request.criterion, (await analyzer.dataflow()).graph, (await analyzer.normalize()).idMap);
         (0, send_1.sendMessage)(this.socket, {
             type: 'response-lineage',
             id: request.id,
@@ -347,10 +342,7 @@ class FlowRServerConnection {
             });
             return;
         }
-        const { dataflow: dfg, normalize: ast } = fileInformation.pipeline.getResults(true);
-        (0, assert_1.guard)(dfg !== undefined, `Dataflow graph must be present (request: ${request.filetoken})`);
-        (0, assert_1.guard)(ast !== undefined, `AST must be present (request: ${request.filetoken})`);
-        void Promise.resolve((0, query_1.executeQueries)({ dataflow: dfg, ast, config: this.config }, request.query)).then(results => {
+        void Promise.resolve(fileInformation.analyzer.query(request.query)).then(results => {
             (0, send_1.sendMessage)(this.socket, {
                 type: 'response-query',
                 id: request.id,
@@ -368,17 +360,17 @@ class FlowRServerConnection {
     }
 }
 exports.FlowRServerConnection = FlowRServerConnection;
-function sanitizeAnalysisResults(results) {
+function sanitizeAnalysisResults(parse, normalize, dataflow) {
     return {
-        ...results,
+        parse: parse,
         normalize: {
-            ...results.normalize,
+            ...normalize,
             idMap: undefined
         },
         dataflow: {
-            ...results.dataflow,
+            ...dataflow,
             // we want to keep the DataflowGraph type information, but not the idMap
-            graph: new graph_1.DataflowGraph(undefined).mergeWith(results.dataflow?.graph)
+            graph: new graph_1.DataflowGraph(undefined).mergeWith(dataflow?.graph)
         }
     };
 }

package/cli/repl/server/messages/message-slice.d.ts

@@ -17,7 +17,7 @@ export interface SliceRequestMessage extends IdMessageBase {
     /** The direction to slice in. Defaults to backward slicing if unset. */
     direction?: SliceDirection;
     /**
-     * Should the magic comments (force-including lines within the slice) be ignord?
+     * Should the magic comments (force-including lines within the slice) be ignored?
      */
     noMagicComments?: boolean;
 }