@eagleoutice/flowr 2.6.1 → 2.6.3

package/r-bridge/parser.d.ts

@@ -1,19 +1,40 @@
-import type { RParseRequest, RParseRequests } from './retriever';
-import type { RShell } from './shell';
+import type { RParseRequestFromText } from './retriever';
+import type { OutputCollectorConfiguration, RShell } from './shell';
 import type { RShellExecutor } from './shell-executor';
 import type { TreeSitterExecutor } from './lang-4.x/tree-sitter/tree-sitter-executor';
+import type { Query, QueryCapture } from 'web-tree-sitter';
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { FlowrAnalyzerContext } from '../project/context/flowr-analyzer-context';
 interface ParserContent<T> {
     readonly name: string;
-    rVersion(): Promise<string | 'unknown' | 'none'>;
-    parse(request: RParseRequest): T;
+    information(analyzer: FlowrAnalysisProvider): BaseParserInformation;
+    parse(request: RParseRequestFromText): T;
     close(): void;
 }
-export interface TreeSitterInformation {
-    name: TreeSitterExecutor['name'];
+export interface BaseParserInformation {
+    readonly name: KnownParserName;
 }
-export interface RShellInformation {
-    name: RShell['name'];
-    rVersion: string;
+export interface BaseRShellInformation extends BaseParserInformation {
+    readonly name: 'r-shell';
+    rVersion(): Promise<string>;
+}
+export interface RShellInformation extends BaseRShellInformation {
+    /**
+     * Sends a command to the underlying R engine and collects the output.
+     * @param command     - The command to send to the R engine.
+     * @param addonConfig - Additional configuration for the output collector.
+     */
+    sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
+}
+export interface TreeSitterInformation extends BaseParserInformation {
+    readonly name: 'tree-sitter';
+    readonly grammarVersion: number;
+    /**
+     * Runs the given tree-sitter query using the underlying tree-sitter parser and returns the resulting capture.
+     * @param source - The tree-sitter query to run.
+     * @param force  - Do not use the cache, instead force a new parse.
+     */
+    treeSitterQuery(source: Query | string, force?: boolean): Promise<QueryCapture[]>;
 }
 export type SyncParser<T> = ParserContent<Awaited<T>> & {
     readonly async?: false;
@@ -24,26 +45,36 @@ export type AsyncParser<T> = ParserContent<Promise<T>> & {
 export type Parser<T> = SyncParser<T> | AsyncParser<T>;
 export type KnownParser = RShell | RShellExecutor | TreeSitterExecutor;
 export type KnownParserType = Awaited<ReturnType<KnownParser['parse']>>;
+export type KnownParserInformation = ReturnType<KnownParser['information']>;
 export type KnownParserName = KnownParser['name'];
 export interface ParseRequiredInput<T> {
     /** This is the {@link RShell}, {@link RShellExecutor} or {@link TreeSitterExecutor} connection to be used to obtain the original parses AST of the R code */
     readonly parser: Parser<T>;
-    /** The request which essentially indicates the input to extract the AST from */
-    readonly request: RParseRequests;
+    /**
+     * The context from which to derive the requests from,
+     * please either relay on the {@link FlowrAnalyzer}
+     * or construct one with {@link contextFromInput}
+     */
+    readonly context: FlowrAnalyzerContext;
 }
-export interface ParseStepOutput<T> {
+export interface ParseStepOutputSingleFile<T> {
     /** The parsed AST of the R code as given by the R parse side */
     readonly parsed: T;
+    readonly filePath: string | undefined;
     /** Additional meta information about the parse */
     readonly '.parse-meta'?: {
         /** The number of tokens in the AST */
         readonly tokenCount: number;
     };
 }
+export interface ParseStepOutput<T> {
+    readonly files: ParseStepOutputSingleFile<T>[];
+}
 /**
  * Takes an input program and parses it using the given parser.
  * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
  * @param input    - the input to the parse step
+ * @returns The parsed AST per request in the loading order obtained from the {@link FlowrAnalyzerFilesContext|files context} of the given {@link FlowrAnalyzerContext}.
  */
 export declare function parseRequests<T extends KnownParserType>(_results: unknown, input: Partial<ParseRequiredInput<T>>): Promise<ParseStepOutput<T>>;
 export {};

package/r-bridge/parser.js

@@ -12,26 +12,40 @@ function countChildren(node) {
  * Takes an input program and parses it using the given parser.
  * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
  * @param input    - the input to the parse step
+ * @returns The parsed AST per request in the loading order obtained from the {@link FlowrAnalyzerFilesContext|files context} of the given {@link FlowrAnalyzerContext}.
  */
 async function parseRequests(_results, input) {
+    const loadingOrder = input.context.files.loadingOrder.getLoadingOrder();
     /* in the future, we want to expose all cases */
-    const request = (Array.isArray(input.request) ? input.request[0] : input.request);
+    const translatedRequests = loadingOrder.map(r => input.context.files.resolveRequest(r));
     if (input.parser?.async) {
-        const parsed = await input.parser.parse(request);
-        return {
-            parsed,
-            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
-                tokenCount: countChildren(parsed.rootNode),
-            } : undefined
-        };
+        /* sadly we cannot Promise.all with the Rshell as it has to process commands in order and is not thread safe */
+        const files = [];
+        for (const req of translatedRequests) {
+            const parsed = await (input.parser).parse(req.r);
+            files.push({
+                parsed,
+                filePath: req.path,
+                '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                    tokenCount: countChildren(parsed.rootNode),
+                } : undefined
+            });
+        }
+        return { files };
     }
     else {
-        const parsed = input.parser.parse(request);
+        const p = input.parser;
         return {
-            parsed,
-            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
-                tokenCount: countChildren(parsed.rootNode),
-            } : undefined
+            files: translatedRequests.map(r => {
+                const parsed = p.parse(r.r);
+                return {
+                    parsed,
+                    filePath: r.path,
+                    '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                        tokenCount: countChildren(parsed.rootNode),
+                    } : undefined
+                };
+            })
         };
     }
 }

package/r-bridge/retriever.d.ts

@@ -1,25 +1,22 @@
 import { type RShell } from './shell';
 import type { AsyncOrSync } from 'ts-essentials';
 import { RShellExecutor } from './shell-executor';
-import type { NormalizedAst } from './lang-4.x/ast/model/processing/decorate';
-import type { SupportedFormats } from '../util/formats/adapter-format';
+import { type NormalizedAst } from './lang-4.x/ast/model/processing/decorate';
 export declare const fileProtocol = "file://";
-export interface ParseRequestAdditionalInfoBase {
-    type: SupportedFormats;
-}
-export interface RParseRequestFromFile<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
+export interface RParseRequestFromFile {
     readonly request: 'file';
     /**
-     * The path to the file (an absolute path is probably best here).
+     * The path to the file represented in the {@link FlowrAnalyzerFilesContext}.
      * See {@link RParseRequests} for multiple files.
      */
     readonly content: string;
-    /**
-     * Additional info from different file formates like .Rmd
-     */
-    readonly info?: AdditionalInfo;
 }
-export interface RParseRequestFromText<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
+/**
+ * A request to parse R code given as text.
+ * This option is mostly useful for quick tests or injects, as usually files are controlled by the {@link RParseRequestFromFile} request
+ * referring to a file in the {@link FlowrAnalyzerFilesContext}.
+ */
+export interface RParseRequestFromText {
     readonly request: 'text';
     /**
      * Source code to parse (not a file path).
@@ -28,10 +25,6 @@ export interface RParseRequestFromText<AdditionalInfo extends ParseRequestAdditi
      * or concatenate their contents to pass them with this request.
      */
     readonly content: string;
-    /**
-     * Additional info from different file formates like .Rmd
-     */
-    readonly info?: AdditionalInfo;
 }
 /**
  * A provider for an {@link RParseRequests} that can be used, for example, to override source file parsing behavior in tests
@@ -46,15 +39,30 @@ export type RParseRequest = RParseRequestFromFile | RParseRequestFromText;
  * Several requests that can be passed along to {@link retrieveParseDataFromRCode}.
  */
 export type RParseRequests = RParseRequest | ReadonlyArray<RParseRequest>;
+/**
+ * Type guard for {@link RParseRequest}
+ */
 export declare function isParseRequest(request: unknown): request is RParseRequest;
 export declare function requestFromInput(input: `${typeof fileProtocol}${string}`): RParseRequestFromFile;
 export declare function requestFromInput(input: `${typeof fileProtocol}${string}`[]): RParseRequestFromFile[];
 export declare function requestFromInput(input: string): RParseRequestFromText;
 export declare function requestFromInput(input: readonly string[] | string): RParseRequests;
+/**
+ * Creates a {@link RParseRequestProvider} that reads from the file system.
+ * Uses `fs.existsSync` to check for file existence.
+ * @see {@link requestProviderFromText} for a provider that reads from a text map.
+ */
 export declare function requestProviderFromFile(): RParseRequestProvider;
+/**
+ * Creates a {@link RParseRequestProvider} that reads from the given text map.
+ * @see {@link requestProviderFromFile} for a provider that reads from the file system.
+ */
 export declare function requestProviderFromText(text: Readonly<{
     [path: string]: string;
 }>): RParseRequestProvider;
+/**
+ * Checks whether the given {@link RParseRequest} is empty (has no content).
+ */
 export declare function isEmptyRequest(request: RParseRequest): boolean;
 export declare function retrieveParseDataFromRCode(request: RParseRequest, shell: RShell): Promise<string>;
 export declare function retrieveParseDataFromRCode(request: RParseRequest, shell: RShellExecutor): string;
@@ -62,6 +70,7 @@ export declare function retrieveParseDataFromRCode(request: RParseRequest, shell
 /**
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows further querying the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ * This function is outdated and should only be used for legacy reasons. Please use the {@link FlowrAnalyzer} instead.
  */
 export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, shell: RShell): Promise<NormalizedAst>;
 /**

package/r-bridge/retriever.js

@@ -23,8 +23,10 @@ const decorate_1 = require("./lang-4.x/ast/model/processing/decorate");
 const type_1 = require("./lang-4.x/ast/model/type");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const adapter_1 = require("../util/formats/adapter");
 exports.fileProtocol = 'file://';
+/**
+ * Type guard for {@link RParseRequest}
+ */
 function isParseRequest(request) {
     if (typeof request !== 'object' || request === null) {
         return false;
@@ -36,20 +38,32 @@ function isParseRequest(request) {
  * If your input starts with {@link fileProtocol}, it is assumed to be a file path and will be processed as such.
  * Giving an array, you can mix file paths and text content (again using the {@link fileProtocol}).
  *
+ * To obtain a {@link FlowrAnalyzerContext} from such an input, use {@link contextFromInput}.
  */
-function requestFromInput(input, fileTypeHint) {
+function requestFromInput(input) {
     if (Array.isArray(input)) {
         return input.flatMap(requestFromInput);
     }
     const content = input;
     const file = content.startsWith(exports.fileProtocol);
     if (file) {
-        return (0, adapter_1.requestFromFile)(content.slice(7));
+        return {
+            request: 'file',
+            content: content.substring(exports.fileProtocol.length),
+        };
     }
     else {
-        return (0, adapter_1.requestFromText)(content, fileTypeHint);
+        return {
+            request: 'text',
+            content
+        };
     }
 }
+/**
+ * Creates a {@link RParseRequestProvider} that reads from the file system.
+ * Uses `fs.existsSync` to check for file existence.
+ * @see {@link requestProviderFromText} for a provider that reads from a text map.
+ */
 function requestProviderFromFile() {
     return {
         exists(p, ignoreCase) {
@@ -76,6 +90,10 @@ function requestProviderFromFile() {
         }
     };
 }
+/**
+ * Creates a {@link RParseRequestProvider} that reads from the given text map.
+ * @see {@link requestProviderFromFile} for a provider that reads from the file system.
+ */
 function requestProviderFromText(text) {
     return {
         exists(path, ignoreCase) {
@@ -92,6 +110,9 @@ function requestProviderFromText(text) {
         }
     };
 }
+/**
+ * Checks whether the given {@link RParseRequest} is empty (has no content).
+ */
 function isEmptyRequest(request) {
     return request.content.trim().length === 0;
 }
@@ -119,10 +140,13 @@ function retrieveParseDataFromRCode(request, shell) {
 /**
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows further querying the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ * This function is outdated and should only be used for legacy reasons. Please use the {@link FlowrAnalyzer} instead.
  */
 async function retrieveNormalizedAstFromRCode(request, shell) {
     const data = await retrieveParseDataFromRCode(request, shell);
-    return (0, parser_1.normalize)({ parsed: data }, (0, decorate_1.deterministicCountingIdGenerator)(0), request.request === 'file' ? request.content : undefined);
+    return (0, parser_1.normalize)({
+        files: [{ parsed: data, filePath: request.request === 'file' ? request.content : undefined }]
+    }, (0, decorate_1.deterministicCountingIdGenerator)(0));
 }
 /**
  * If the string has (R-)quotes around it, they will be removed; otherwise the string is returned unchanged.

package/r-bridge/shell-executor.d.ts

@@ -1,6 +1,6 @@
-import type { RShellExecutionOptions } from './shell';
+import { type RShellExecutionOptions } from './shell';
 import type { SemVer } from 'semver';
-import type { SyncParser } from './parser';
+import type { BaseRShellInformation, SyncParser } from './parser';
 import { type RParseRequest } from './retriever';
 /**
  * This is a synchronous alternative to the {@link RShell}.
@@ -23,12 +23,12 @@ export declare class RShellExecutor implements SyncParser<string> {
     addPrerequisites(commands: string | string[]): this;
     /**
      * @returns the version of the R interpreter available to this executor.
-     *
      * @see {@link RShellExecutor#usedRVersion}
      * @see {@link RShell#rVersion}
      * @see {@link RShell#usedRVersion}
      */
     rVersion(): Promise<string | 'unknown' | 'none'>;
+    information(): BaseRShellInformation;
     /**
      * Instead of returning a promise, this method returns the version of the R interpreter available to this executor,
      * in the SemVer format.

package/r-bridge/shell-executor.js

@@ -40,7 +40,6 @@ class RShellExecutor {
     }
     /**
      * @returns the version of the R interpreter available to this executor.
-     *
      * @see {@link RShellExecutor#usedRVersion}
      * @see {@link RShell#rVersion}
      * @see {@link RShell#usedRVersion}
@@ -48,6 +47,12 @@ class RShellExecutor {
     rVersion() {
         return Promise.resolve(this.usedRVersion()?.format() ?? 'unknown');
     }
+    information() {
+        return {
+            name: 'r-shell',
+            rVersion: () => Promise.resolve(this.rVersion())
+        };
+    }
     /**
      * Instead of returning a promise, this method returns the version of the R interpreter available to this executor,
      * in the SemVer format.

package/r-bridge/shell.d.ts

@@ -2,13 +2,13 @@ import { type MergeableRecord } from '../util/objects';
 import type { SemVer } from 'semver';
 import type { AsyncOrSync } from 'ts-essentials';
 import type { RShellEngineConfig } from '../config';
-import type { AsyncParser } from './parser';
-import type { RParseRequest } from './retriever';
+import type { AsyncParser, RShellInformation } from './parser';
+import { type RParseRequest } from './retriever';
 export type OutputStreamSelector = 'stdout' | 'stderr' | 'both';
 export interface CollectorTimeout extends MergeableRecord {
     /**
-   * number of milliseconds to wait for the collection to finish
-   */
+     * number of milliseconds to wait for the collection to finish
+     */
     ms: number;
     resetOnNewData: boolean;
     /**
@@ -24,9 +24,9 @@ export interface OutputCollectorConfiguration extends MergeableRecord {
     /** the streams to use to collect the output from */
     from: OutputStreamSelector;
     /**
-   * a string marker to signal that the command was executed successfully.
-   * must not appear as a standalone line in the output. this is our hacky way of ensuring that we are done.
-   */
+     * a string marker to signal that the command was executed successfully.
+     * must not appear as a standalone line in the output. this is our hacky way of ensuring that we are done.
+     */
     postamble: string;
     /** internal timeout configuration to use (see {@link CollectorTimeout}) */
     timeout: CollectorTimeout;
@@ -69,6 +69,9 @@ export interface RShellOptions extends RShellSessionOptions {
     readonly sessionName: string;
 }
 export declare const DEFAULT_R_PATH: string;
+/**
+ * Get the default RShell options, possibly using the given config to override some values
+ */
 export declare function getDefaultRShellOptions(config?: RShellEngineConfig): RShellOptions;
 /**
  * The `RShell` represents an interactive session with the R interpreter.
@@ -88,6 +91,7 @@ export declare class RShell implements AsyncParser<string> {
     private tempDirs;
     constructor(config?: RShellEngineConfig, options?: Partial<RShellOptions>);
     parse(request: RParseRequest): Promise<string>;
+    information(): RShellInformation;
     private revive;
     /**
      * sends the given command directly to the current R session
@@ -103,22 +107,20 @@ export declare class RShell implements AsyncParser<string> {
      */
     isPackageInstalled(packageName: string): Promise<boolean>;
     /**
-   * Send a command and collect the output
-   *
-   * @param command     - The R command to execute (similar to {@link sendCommand})
-   * @param addonConfig - Further configuration on how and what to collect: see {@link OutputCollectorConfiguration},
-   *                      defaults are set in {@link DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION}
-   */
+     * Send a command and collect the output
+     * @param command     - The R command to execute (similar to {@link sendCommand})
+     * @param addonConfig - Further configuration on how and what to collect: see {@link OutputCollectorConfiguration},
+     *                      defaults are set in {@link DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION}
+     */
     sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
     /**
-   * execute multiple commands in order
-   *
-   * @see sendCommand
-   */
+     * execute multiple commands in order
+     * @see sendCommand
+     */
     sendCommands(...commands: readonly string[]): void;
     /**
-   * clears the R environment using the `rm` command.
-   */
+     * clears the R environment using the `rm` command.
+     */
     clearEnvironment(): void;
     /**
      * Obtain the temporary directory used by R.
@@ -126,10 +128,9 @@ export declare class RShell implements AsyncParser<string> {
      */
     obtainTmpDir(): Promise<string>;
     /**
-   * Close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
-   *
-   * @returns true if the operation succeeds, false otherwise
-   */
+     * Close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
+     * @returns true if the operation succeeds, false otherwise
+     */
     close(): boolean;
     private _sendCommand;
 }

package/r-bridge/shell.js

@@ -61,6 +61,9 @@ exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
 };
 exports.DEFAULT_R_PATH = (0, os_1.getPlatform)() === 'windows' ? 'R.exe' : 'R';
 let DEFAULT_R_SHELL_OPTIONS = undefined;
+/**
+ * Get the default RShell options, possibly using the given config to override some values
+ */
 function getDefaultRShellOptions(config) {
     if (!DEFAULT_R_SHELL_OPTIONS) {
         DEFAULT_R_SHELL_OPTIONS = {
@@ -105,6 +108,15 @@ class RShell {
     parse(request) {
         return (0, retriever_1.retrieveParseDataFromRCode)(request, this);
     }
+    information() {
+        return {
+            name: 'r-shell',
+            rVersion: async () => await this.rVersion(),
+            sendCommandWithOutput: (command, addonConfig) => {
+                return this.sendCommandWithOutput(command, addonConfig);
+            }
+        };
+    }
     revive() {
         if (this.options.revive === 0 /* RShellReviveOptions.Never */) {
             return;
@@ -177,12 +189,11 @@ class RShell {
         return result.length === 1 && result[0] === 'TRUE';
     }
     /**
-   * Send a command and collect the output
-   *
-   * @param command     - The R command to execute (similar to {@link sendCommand})
-   * @param addonConfig - Further configuration on how and what to collect: see {@link OutputCollectorConfiguration},
-   *                      defaults are set in {@link DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION}
-   */
+     * Send a command and collect the output
+     * @param command     - The R command to execute (similar to {@link sendCommand})
+     * @param addonConfig - Further configuration on how and what to collect: see {@link OutputCollectorConfiguration},
+     *                      defaults are set in {@link DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION}
+     */
     async sendCommandWithOutput(command, addonConfig) {
         const config = (0, objects_1.deepMergeObject)(exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION, addonConfig);
         (0, log_1.expensiveTrace)(this.log, () => `> ${JSON.stringify(command)}`);
@@ -206,18 +217,17 @@ class RShell {
         }
     }
     /**
-   * execute multiple commands in order
-   *
-   * @see sendCommand
-   */
+     * execute multiple commands in order
+     * @see sendCommand
+     */
     sendCommands(...commands) {
         for (const element of commands) {
             this.sendCommand(element);
         }
     }
     /**
-   * clears the R environment using the `rm` command.
-   */
+     * clears the R environment using the `rm` command.
+     */
     clearEnvironment() {
         this.log.debug('clearing environment');
         // run rm(list=ls()) but ignore 'flowr_get_ast', which is the compile command installed
@@ -234,10 +244,9 @@ class RShell {
         return tempdir;
     }
     /**
-   * Close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
-   *
-   * @returns true if the operation succeeds, false otherwise
-   */
+     * Close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
+     * @returns true if the operation succeeds, false otherwise
+     */
     close() {
         return this.session.end([...this.tempDirs]);
     }
@@ -294,15 +303,14 @@ class RShellSession {
         this.write(`${data}${this.options.eol}`);
     }
     /**
-   * Collect lines from the selected streams until the given condition is met or the timeout is reached
-   *
-   * This method does allow other listeners to consume the same input
-   *
-   * @param from        - The stream(s) to collect the information from
-   * @param until       - If the predicate returns true, this will stop the collection and resolve the promise
-   * @param timeout     - Configuration for how and when to timeout
-   * @param action      - Event to be performed after all listeners are installed, this might be the action that triggers the output you want to collect
-   */
+     * Collect lines from the selected streams until the given condition is met or the timeout is reached
+     *
+     * This method does allow other listeners to consume the same input
+     * @param from        - The stream(s) to collect the information from
+     * @param until       - If the predicate returns true, this will stop the collection and resolve the promise
+     * @param timeout     - Configuration for how and when to timeout
+     * @param action      - Event to be performed after all listeners are installed, this might be the action that triggers the output you want to collect
+     */
     async collectLinesUntil(from, until, timeout, action) {
         const result = [];
         let handler;
@@ -344,13 +352,11 @@ class RShellSession {
         });
     }
     /**
-   * close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
-   *
+     * close the current R session, makes the object effectively invalid (can no longer be reopened etc.)
      * @param filesToUnlink - If set, these files will be unlinked before closing the session (e.g., to clean up tempfiles)
-     *
-   * @returns true if the kill succeeds, false otherwise
-   * @see RShell#close
-   */
+     * @returns true if the kill succeeds, false otherwise
+     * @see RShell#close
+     */
     end(filesToUnlink) {
         if (filesToUnlink !== undefined) {
             log_1.log.info(`unlinking ${filesToUnlink.length} files (${JSON.stringify(filesToUnlink)})`);

package/reconstruct/auto-select/auto-select-defaults.d.ts

@@ -4,10 +4,8 @@ import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/a
  * The structure of the predicate that should be used to determine
  * if a given normalized node should be included in the reconstructed code,
  * independent of if it is selected by the slice or not.
- *
  * @see reconstructToCode
  * @see doNotAutoSelect
- * @see autoSelectLibrary
  */
 export type AutoSelectPredicate = (node: RNode<ParentInformation>, fullAst: NormalizedAst) => boolean;
 /**

package/reconstruct/auto-select/magic-comments.d.ts

@@ -7,10 +7,9 @@ import type { AutoSelectPredicate } from './auto-select-defaults';
  * We support two formats:
  * - Line comments in the form of `# flowr@include_next_line` or `# flowr@include_this_line`.
  * - Block comments which start with `# flowr@include_start` and end with `# flowr@include_end`.
- *   This supports nesting, but they have to appear on a single line.
+ * This supports nesting, but they have to appear on a single line.
  *
  * Please note that these comments have to start exactly with this content to work.
- *
  * @param and - Predicate to composite this one with, If you do not pass a predicate, you may assume composition with
  *              {@link doNotAutoSelect}.
  */

package/reconstruct/auto-select/magic-comments.js

@@ -40,10 +40,9 @@ const commentTriggerRegex = / flowr@(\w+)/;
  * We support two formats:
  * - Line comments in the form of `# flowr@include_next_line` or `# flowr@include_this_line`.
  * - Block comments which start with `# flowr@include_start` and end with `# flowr@include_end`.
- *   This supports nesting, but they have to appear on a single line.
+ * This supports nesting, but they have to appear on a single line.
  *
  * Please note that these comments have to start exactly with this content to work.
- *
  * @param and - Predicate to composite this one with, If you do not pass a predicate, you may assume composition with
  *              {@link doNotAutoSelect}.
  */
@@ -53,7 +52,7 @@ function makeMagicCommentHandler(and) {
         if (!lines) {
             lines = new Set();
             const startLineStack = [];
-            (0, visitor_1.visitAst)(normalizedAst.ast, n => {
+            (0, visitor_1.visitAst)(normalizedAst.ast.files.map(f => f.root), n => {
                 const comments = n.info.additionalTokens;
                 if (!comments) {
                     return;