@eagleoutice/flowr 2.6.2 → 2.6.3

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor.d.ts

@@ -3,7 +3,7 @@ import type { Query, QueryCapture } from 'web-tree-sitter';
 import type { RParseRequest } from '../../retriever';
 import type { SyncParser, TreeSitterInformation } from '../../parser';
 import type { TreeSitterEngineConfig } from '../../../config';
-import type { FlowrAnalysisProvider } from '../../../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 export declare const DEFAULT_TREE_SITTER_R_WASM_PATH = "./node_modules/@eagleoutice/tree-sitter-r/tree-sitter-r.wasm";
 export declare const DEFAULT_TREE_SITTER_WASM_PATH = "./node_modules/web-tree-sitter/tree-sitter.wasm";
 /**
@@ -22,10 +22,10 @@ export declare class TreeSitterExecutor implements SyncParser<Parser.Tree> {
     static initTreeSitter(config?: TreeSitterEngineConfig, overrideWasmPath?: string, overrideTreeSitterWasmPath?: string): Promise<void>;
     constructor();
     rVersion(): Promise<string | 'unknown' | 'none'>;
-    information(analyzer: FlowrAnalysisProvider): TreeSitterInformation;
+    information(analyzer: ReadonlyFlowrAnalysisProvider): TreeSitterInformation;
     treeSitterVersion(): number;
     parse(request: RParseRequest): Parser.Tree;
     createQuery(source: string): Query;
-    query(source: Query | string, tree: Parser.Tree): QueryCapture[];
+    query(source: Query | string, ...tree: Parser.Tree[]): QueryCapture[];
     close(): void;
 }

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor.js

@@ -53,7 +53,7 @@ class TreeSitterExecutor {
             name: 'tree-sitter',
             grammarVersion: this.treeSitterVersion(),
             treeSitterQuery: async (source, force) => {
-                return this.query(source, (await analyzer.parse(force)).parsed);
+                return this.query(source, ...(await analyzer.parse(force)).files.map(p => p.parsed));
             }
         };
     }
@@ -73,10 +73,11 @@ class TreeSitterExecutor {
     createQuery(source) {
         return this.parser.getLanguage().query(source);
     }
-    query(source, tree) {
+    query(source, ...tree) {
         const query = typeof source === 'string' ? this.createQuery(source) : source;
-        const matches = query.matches(tree.rootNode);
-        return matches.flatMap(m => m.captures);
+        return tree
+            .flatMap(t => query.matches(t.rootNode))
+            .flatMap(m => m.captures);
     }
     close() {
         this.parser.delete();

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.d.ts

@@ -1,5 +1,6 @@
-import type { RExpressionList } from '../ast/model/nodes/r-expression-list';
 import type { Tree } from 'web-tree-sitter';
+import type { RProject } from '../ast/model/nodes/r-project';
+import type { ParseStepOutputSingleFile } from '../../parser';
 export interface TreeSitterInfo {
     treeSitterId: number;
 }
@@ -7,7 +8,7 @@ export interface TreeSitterInfo {
  * @param tree - The tree to normalize
  * @param lax - Whether to use lax parsing (i.e., ignore errors) or strict parsing (i.e., fail on errors)
  */
-export declare function normalizeTreeSitterTreeToAst(tree: Tree, lax?: boolean): RExpressionList<TreeSitterInfo>;
+export declare function normalizeTreeSitterTreeToAst(tree: ParseStepOutputSingleFile<Tree>[], lax?: boolean): RProject<TreeSitterInfo>;
 /**
  * Globally switch to lax parsing mode for tree-sitter normalization
  * @see {@link makeTreeSitterStrict}

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -24,11 +24,20 @@ function normalizeTreeSitterTreeToAst(tree, lax) {
     else {
         makeTreeSitterStrict();
     }
-    const root = convertTreeNode(tree.rootNode);
-    if (root.type !== type_1.RType.ExpressionList) {
-        throw new normalizer_data_1.ParseError(`expected root to resolve to an expression list, got a ${root.type}`);
-    }
-    return root;
+    const files = tree.map(t => {
+        const root = convertTreeNode(t.parsed.rootNode);
+        if (root.type !== type_1.RType.ExpressionList) {
+            throw new normalizer_data_1.ParseError(`expected root to resolve to an expression list, got a ${root.type}`);
+        }
+        return {
+            filePath: t.filePath,
+            root: root
+        };
+    });
+    return {
+        type: type_1.RType.Project,
+        files
+    };
 }
 function nonErrorChildrenStrict(node) {
     return node.hasError ? [] : node.children;

package/r-bridge/parser.d.ts

@@ -1,13 +1,14 @@
-import type { RParseRequest, RParseRequests } from './retriever';
+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;
     information(analyzer: FlowrAnalysisProvider): BaseParserInformation;
-    parse(request: RParseRequest): T;
+    parse(request: RParseRequestFromText): T;
     close(): void;
 }
 export interface BaseParserInformation {
@@ -49,22 +50,31 @@ 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

@@ -2,24 +2,21 @@ 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';
 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
@@ -77,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,7 +23,6 @@ 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}
@@ -39,18 +38,25 @@ 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
+        };
     }
 }
 /**
@@ -134,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.d.ts

@@ -70,7 +70,7 @@ export interface RShellOptions extends RShellSessionOptions {
 }
 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;
 /**

package/r-bridge/shell.js

@@ -62,7 +62,7 @@ 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) {

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

@@ -6,7 +6,6 @@ import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/a
  * 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.js

@@ -52,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;

package/reconstruct/reconstruct.d.ts

@@ -6,19 +6,27 @@
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type AutoSelectPredicate } from './auto-select/auto-select-defaults';
-type Selection = ReadonlySet<NodeId>;
+interface Selection {
+    /**
+     * The set of node ids to be reconstructed.
+     */
+    nodes: ReadonlySet<NodeId>;
+    /**
+     * @see {@link ReconstructRequiredInput#reconstructFiles}
+     */
+    reconstructFiles?: 'all' | number[];
+}
 export declare const reconstructLogger: import("tslog").Logger<import("tslog").ILogObj>;
 export interface ReconstructionResult {
-    code: string;
+    /** Returns the reconstructed code as string or array of code reconstructions (corresponding to the desired file indices in the {@link Selection}) */
+    code: string | string[];
     /** number of lines that contain nodes that triggered the `autoSelectIf` predicate {@link reconstructToCode} */
     linesWithAutoSelected: number;
 }
-/**
- * Reconstructs parts of a normalized R ast into R code on an expression basis.
- * @param ast          - The {@link NormalizedAst|normalized ast} to be used as a basis for reconstruction
- * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
- * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
- * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
- */
+export declare function reconstructToCode(ast: NormalizedAst, selection: Selection & {
+    reconstructFiles?: [number] | undefined;
+}, autoSelectIf?: AutoSelectPredicate): ReconstructionResult & {
+    code: string;
+};
 export declare function reconstructToCode(ast: NormalizedAst, selection: Selection, autoSelectIf?: AutoSelectPredicate): ReconstructionResult;
 export {};

package/reconstruct/reconstruct.js

@@ -408,25 +408,25 @@ function getIndentString(indent) {
 function prettyPrintCodeToString(code, lf = '\n') {
     return code.map(({ line, indent }) => `${getIndentString(indent)}${line}`).join(lf);
 }
-function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
+function removeOuterExpressionListIfApplicable(result) {
     if (result.length > 1 && result[0].line === '{' && result[result.length - 1].line === '}') {
         // remove outer block
-        return { code: prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1)), linesWithAutoSelected };
+        return prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1));
     }
     else {
-        return { code: prettyPrintCodeToString(result), linesWithAutoSelected };
+        return prettyPrintCodeToString(result);
     }
 }
 /**
  * Reconstructs parts of a normalized R ast into R code on an expression basis.
  * @param ast          - The {@link NormalizedAst|normalized ast} to be used as a basis for reconstruction
  * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
- * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
+ * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
 function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.doNotAutoSelect) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
-        exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
+        exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection.nodes])} for files: ${JSON.stringify(selection.reconstructFiles)}`);
     }
     // we use a wrapper to count the number of lines for which the autoSelectIf predicate triggered
     const linesWithAutoSelected = new Set();
@@ -439,9 +439,20 @@ function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1
         }
         return result;
     };
+    const indices = selection.reconstructFiles === 'all' ? ast.ast.files.map((_, i) => i) : (selection.reconstructFiles ?? [0]);
+    (0, assert_1.guard)(indices.every(i => i >= 0 && i < ast.ast.files.length), `reconstructToCode: reconstructFiles contains invalid file indices: ${JSON.stringify(indices)} for ast with ${ast.ast.files.length} files`);
+    const results = [];
     // fold of the normalized ast
-    const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper, fullAst: ast }, reconstructAstFolds);
-    (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(result)}`);
-    return removeOuterExpressionListIfApplicable(result, linesWithAutoSelected.size);
+    for (const i of indices) {
+        if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
+            exports.reconstructLogger.trace(`reconstructing file index ${i} with root id ${ast.ast.files[i].root.info.id}`);
+        }
+        results.push(removeOuterExpressionListIfApplicable((0, stateful_fold_1.foldAstStateful)(ast.ast.files[i].root, { selection: selection.nodes, autoSelectIf: autoSelectIfWrapper, fullAst: ast }, reconstructAstFolds)));
+    }
+    (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(results)}`);
+    return {
+        code: indices.length === 1 ? results[0] : results,
+        linesWithAutoSelected: linesWithAutoSelected.size
+    };
 }
 //# sourceMappingURL=reconstruct.js.map

package/search/flowr-search.d.ts

@@ -41,6 +41,18 @@ export interface FlowrSearchGetFilter extends Record<string, unknown> {
      * The node must have the given id.
      */
     readonly id?: NodeId;
+    /**
+     * The node must stem form a file with the given path matching the regex
+     * Please note that you can address the full path!
+     * @example
+     * ```ts
+     * // matches all files in any 'tests' folder
+     * filePath: '.*\\tests\\.*'
+     * // matches all files named 'myfile.R' in any folder
+     * filePath: '.*\\/myfile\\.R$'
+     * ```
+     */
+    readonly filePathRegex?: string;
 }
 /** Intentionally, we abstract away from an array to avoid the use of conventional typescript operations */
 export declare class FlowrSearchElements<Info = NoInfo, Elements extends FlowrSearchElement<Info>[] = FlowrSearchElement<Info>[]> {

package/search/search-executor/search-enrichers.d.ts

@@ -10,6 +10,7 @@ import { type CfgSimplificationPassName } from '../../control-flow/cfg-simplific
 import type { AsyncOrSync } from 'ts-essentials';
 import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { FlowrConfigOptions } from '../../config';
 export interface EnrichmentData<ElementContent extends MergeableRecord, ElementArguments = undefined, SearchContent extends MergeableRecord = never, SearchArguments = ElementArguments> {
     /**
      * A function that is applied to each element of the search to enrich it with additional data.
@@ -18,6 +19,7 @@ export interface EnrichmentData<ElementContent extends MergeableRecord, ElementA
         dataflow: DataflowInformation;
         normalize: NormalizedAst;
         cfg: ControlFlowInformation;
+        config: FlowrConfigOptions;
     }, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => AsyncOrSync<ElementContent>;
     readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: ReadonlyFlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
     /**
@@ -98,6 +100,7 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: {
             onlyBuiltin?: boolean;
         } | undefined, prev: CallTargetsContent | undefined) => CallTargetsContent;
@@ -108,6 +111,7 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
@@ -116,19 +120,21 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, _args: CfgInformationArguments | undefined, prev: CfgInformationElementContent | undefined) => {
             isRoot: boolean;
             isReachable: boolean | undefined;
         };
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: ReadonlyFlowrAnalysisProvider, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
     };
     readonly "query-data": {
         enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: QueryDataElementContent | undefined, prev: QueryDataElementContent | undefined) => QueryDataElementContent;
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
     };
 };
 /**
@@ -145,4 +151,5 @@ export declare function enrichElement<Element extends FlowrSearchElement<ParentI
     dataflow: DataflowInformation;
     normalize: NormalizedAst;
     cfg: ControlFlowInformation;
+    config: FlowrConfigOptions;
 }, enrichment: E, args?: EnrichmentElementArguments<E>): Promise<Element>;

package/search/search-executor/search-enrichers.js

@@ -7,7 +7,6 @@ const objects_1 = require("../../util/objects");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const identify_link_to_last_call_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const assert_1 = require("../../util/assert");
-const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
@@ -76,9 +75,8 @@ exports.Enrichments = {
             const content = prev ?? { linkedIds: [] };
             const vertex = data.dataflow.graph.get(e.node.info.id);
             if (vertex !== undefined && vertex[0].tag === vertex_1.VertexType.FunctionCall) {
-                const cfg = (0, extract_cfg_1.extractCfgQuick)(data.normalize);
                 for (const arg of args) {
-                    const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, cfg.graph, data.dataflow.graph, {
+                    const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, data.cfg.graph, data.dataflow.graph, {
                         ...arg,
                         callName: (0, call_context_query_executor_1.promoteCallName)(arg.callName),
                         type: 'link-to-last-call',

package/search/search-executor/search-generators.d.ts

@@ -28,7 +28,7 @@ export declare const generators: {
     readonly syntax: typeof generateSyntax;
 };
 declare function generateAll(data: ReadonlyFlowrAnalysisProvider): Promise<FlowrSearchElements<ParentInformation>>;
-declare function generateGet(input: ReadonlyFlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex } }: {
+declare function generateGet(input: ReadonlyFlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex, filePathRegex } }: {
     filter: FlowrSearchGetFilter;
 }): Promise<FlowrSearchElements<ParentInformation>>;
 declare function generateFrom(_input: ReadonlyFlowrAnalysisProvider, args: {

package/search/search-executor/search-generators.js

@@ -30,13 +30,18 @@ async function getAllNodes(data) {
     return [...new Map([...normalize.idMap.values()].map(n => [n.info.id, n]))
             .values()];
 }
-async function generateGet(input, { filter: { line, column, id, name, nameIsRegex } }) {
+async function generateGet(input, { filter: { line, column, id, name, nameIsRegex, filePathRegex } }) {
     const normalize = await input.normalize();
     let potentials = (id ?
         [normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
         await getAllNodes(input));
+    if (filePathRegex) {
+        const filePathFilter = new RegExp(filePathRegex);
+        potentials = potentials.filter(({ info }) => info.file && filePathFilter.test(info.file));
+    }
     if (line && line < 0) {
-        const maxLines = normalize.ast.info.fullRange?.[2] ??
+        (0, assert_1.guard)(normalize.ast.files.length === 1, 'Currently, negative line numbers are only supported for single-file inputs');
+        const maxLines = normalize.ast.files[0].root.info.fullRange?.[2] ??
             (id ? (await getAllNodes(input)) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
         line = maxLines + line + 1;
     }
@@ -85,7 +90,7 @@ async function generateFromQuery(input, args) {
         .enrich(input, search_enrichers_1.Enrichment.QueryData, { queries: result });
     return elements.mutate(s => Promise.all(s.map(async (e) => {
         const [query, _] = [...nodesByQuery].find(([_, nodes]) => nodes.has(e));
-        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg }, search_enrichers_1.Enrichment.QueryData, { query });
+        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg, config: input.flowrConfig }, search_enrichers_1.Enrichment.QueryData, { query });
     })));
 }
 async function generateSyntax(input, args) {
@@ -107,7 +112,7 @@ async function generateSyntax(input, args) {
         return new flowr_search_1.FlowrSearchElements([]);
     }
     const nodesByTreeSitterId = new Map();
-    (0, visitor_1.visitAst)((await input.normalize()).ast, node => {
+    (0, visitor_1.visitAst)((await input.normalize()).ast.files.map(f => f.root), node => {
         const treeSitterInfo = node.info;
         if (treeSitterInfo.treeSitterId) {
             nodesByTreeSitterId.set(treeSitterInfo.treeSitterId, node);

package/slicing/criterion/collect-all.d.ts

@@ -5,8 +5,9 @@
  */
 import type { MergeableRecord } from '../../util/objects';
 import type { SlicingCriteria } from './parse';
-import type { RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { RProject } from '../../r-bridge/lang-4.x/ast/model/nodes/r-project';
 /**
  * Defines the filter for collecting all possible slicing criteria.
  * @see DefaultAllVariablesFilter
@@ -34,4 +35,4 @@ export interface SlicingCriteriaFilter extends MergeableRecord {
  * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
  * If there are not enough matching nodes within the ast, this will return *no* slicing criteria!
  */
-export declare function collectAllSlicingCriteria<OtherInfo>(ast: RNodeWithParent<OtherInfo>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;
+export declare function collectAllSlicingCriteria<OtherInfo>(ast: RProject<OtherInfo & ParentInformation>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;

package/slicing/criterion/collect-all.js

@@ -12,7 +12,7 @@ const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-fun
 function* collectAllSlicingCriteria(ast, filter) {
     (0, assert_1.guard)(filter.minimumSize >= 1, `Minimum size must be at least 1, but was ${filter.minimumSize}`);
     (0, assert_1.guard)(filter.maximumSize >= filter.minimumSize, `Maximum size must be at least minimum size, but was ${filter.maximumSize} < ${filter.minimumSize}`);
-    const potentialSlicingNodes = filter.collectAll(ast);
+    const potentialSlicingNodes = ast.files.flatMap(f => filter.collectAll(f.root));
     if (potentialSlicingNodes.length < filter.minimumSize) {
         return;
     }