@eagleoutice/flowr 2.6.2 → 2.7.0

package/queries/query.js

@@ -10,6 +10,7 @@ exports.SupportedQueriesSchema = SupportedQueriesSchema;
 exports.VirtualQuerySchema = VirtualQuerySchema;
 exports.AnyQuerySchema = AnyQuerySchema;
 exports.QueriesSchema = QueriesSchema;
+exports.genericWrapReplFailIfNoRequest = genericWrapReplFailIfNoRequest;
 const call_context_query_format_1 = require("./catalog/call-context-query/call-context-query-format");
 const assert_1 = require("../util/assert");
 const virtual_queries_1 = require("./virtual-query/virtual-queries");
@@ -19,6 +20,7 @@ const normalized_ast_query_format_1 = require("./catalog/normalized-ast-query/no
 const static_slice_query_format_1 = require("./catalog/static-slice-query/static-slice-query-format");
 const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-format");
 const dependencies_query_format_1 = require("./catalog/dependencies-query/dependencies-query-format");
+const ansi_1 = require("../util/text/ansi");
 const joi_1 = __importDefault(require("joi"));
 const location_map_query_format_1 = require("./catalog/location-map-query/location-map-query-format");
 const config_query_format_1 = require("./catalog/config-query/config-query-format");
@@ -105,7 +107,7 @@ async function executeQueries(data, queries) {
             results.push([type, result]);
         }
         catch (e) {
-            log_1.log.error(e);
+            log_1.log.warn(e);
             results.push([type, undefined]);
         }
     }
@@ -145,4 +147,22 @@ function AnyQuerySchema() {
 function QueriesSchema() {
     return joi_1.default.array().items(AnyQuerySchema()).description('Queries to run on the file analysis information (in the form of an array)');
 }
+/**
+ * Wraps a function that executes a REPL query and, if it fails, checks whether there were any requests to analyze.
+ */
+async function genericWrapReplFailIfNoRequest(fn, output, analyzer) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        if (analyzer.inspectContext().files.loadingOrder.getUnorderedRequests().length === 0) {
+            output.stderr(output.formatter.format('No requests to analyze were found.', { color: 1 /* Colors.Red */, style: 1 /* FontStyles.Bold */, effect: ansi_1.ColorEffect.Foreground })
+                + '\nIf you consider this an error, please report a bug: '
+                + (0, assert_1.getGuardIssueUrl)('analyzer found no requests to analyze'));
+        }
+        else {
+            throw e;
+        }
+    }
+}
 //# sourceMappingURL=query.js.map

package/r-bridge/lang-4.x/ast/model/collect.d.ts

@@ -1,9 +1,10 @@
 import type { RNode } from './model';
 import type { NodeId } from './processing/node-id';
 import type { ParentInformation } from './processing/decorate';
+import type { RProject } from './nodes/r-project';
 /**
  * Collects all node ids within a tree given by a respective root node
  * @param nodes - The root id nodes to start collecting from
  * @param stop  - A function that determines whether to stop collecting at a given node, does not stop by default
  */
-export declare function collectAllIds<OtherInfo>(nodes: RNode<OtherInfo & ParentInformation> | (RNode<OtherInfo & ParentInformation> | null | undefined)[] | undefined, stop?: (node: RNode<OtherInfo & ParentInformation>) => boolean): Set<NodeId>;
+export declare function collectAllIds<OtherInfo>(nodes: RProject<OtherInfo & ParentInformation> | RNode<OtherInfo & ParentInformation> | (RNode<OtherInfo & ParentInformation> | null | undefined)[] | undefined, stop?: (node: RNode<OtherInfo & ParentInformation>) => boolean): Set<NodeId>;

package/r-bridge/lang-4.x/ast/model/collect.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAllIds = collectAllIds;
 const visitor_1 = require("./processing/visitor");
+const type_1 = require("./type");
 /**
  * Collects all node ids within a tree given by a respective root node
  * @param nodes - The root id nodes to start collecting from
  * @param stop  - A function that determines whether to stop collecting at a given node, does not stop by default
  */
 function collectAllIds(nodes, stop = () => false) {
+    if (nodes && 'type' in nodes && nodes.type === type_1.RType.Project) {
+        nodes = nodes.files.map(f => f.root);
+    }
     const ids = new Set();
     (0, visitor_1.visitAst)(nodes, (node) => {
         if (stop(node)) {

package/r-bridge/lang-4.x/ast/model/nodes/r-project.d.ts

@@ -0,0 +1,29 @@
+import type { NoInfo } from '../model';
+import { RType } from '../type';
+import type { RExpressionList } from './r-expression-list';
+import type { NodeId } from '../processing/node-id';
+/**
+ * Holds a single R file starting with an expression list.
+ */
+export interface RProjectFile<Info = NoInfo> {
+    readonly filePath?: string;
+    readonly root: RExpressionList<Info>;
+}
+/**
+ * Holds a collection of files (started with the expression list)
+ * @see {@link RExpressionList} - for the root of each file
+ * @see {@link mergeProjects} - to merge multiple projects into a single one
+ * @see {@link RProjectFile} - for each file in the project
+ */
+export interface RProject<Info = NoInfo> {
+    readonly type: RType.Project;
+    readonly files: RProjectFile<Info>[];
+    readonly info?: {
+        id: NodeId;
+    };
+}
+/**
+ * Merge multiple projects into a single one by concatenating their files.
+ * This will remove the `info` property of the resulting project.
+ */
+export declare function mergeProjects<Info = NoInfo>(projects: RProject<Info>[]): RProject<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-project.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProjects = mergeProjects;
+const type_1 = require("../type");
+/**
+ * Merge multiple projects into a single one by concatenating their files.
+ * This will remove the `info` property of the resulting project.
+ */
+function mergeProjects(projects) {
+    return {
+        type: type_1.RType.Project,
+        files: projects.flatMap(p => p.files)
+    };
+}
+//# sourceMappingURL=r-project.js.map

package/r-bridge/lang-4.x/ast/model/processing/decorate.d.ts

@@ -14,12 +14,13 @@ import type { MergeableRecord } from '../../../../../util/objects';
 import { RoleInParent } from './role';
 import type { NodeId } from './node-id';
 import type { RDelimiter } from '../nodes/info/r-delimiter';
+import type { RProject } from '../nodes/r-project';
 /**
  * A function that given an RNode returns a (guaranteed) unique id for it
  * @param data - the node to generate an id for
  * @returns a unique id for the given node
  */
-export type IdGenerator<OtherInfo> = (data: RNode<OtherInfo>) => NodeId;
+export type IdGenerator<OtherInfo> = (data: RProject<OtherInfo> | RNode<OtherInfo>) => NodeId;
 /**
  * The simplest id generator which just increments a number on each call.
  */
@@ -71,7 +72,7 @@ export type AstIdMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherIn
  * Contains the normalized AST as a doubly linked tree
  * and a map from ids to nodes so that parent links can be chased easily.
  */
-export interface NormalizedAst<OtherInfo = ParentInformation, Node = RNode<OtherInfo & ParentInformation>> {
+export interface NormalizedAst<OtherInfo = ParentInformation, Node = RProject<OtherInfo & ParentInformation>> {
     /** Bidirectional mapping of ids to the corresponding nodes and the other way */
     idMap: AstIdMap<OtherInfo>;
     /** The root of the AST with parent information */
@@ -82,15 +83,12 @@ export interface NormalizedAst<OtherInfo = ParentInformation, Node = RNode<Other
 export interface NormalizedAstDecorationConfiguration<OtherInfo> {
     /** The id generator: must generate a unique id für each passed node */
     getId?: IdGenerator<OtherInfo>;
-    /** the path to the file this AST was extracted from will be added to the nodes */
-    file?: string;
 }
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
- * @param ast   - The root of the AST to convert
+ * @param project - The AST to decorate
  * @param getId - The id generator: must generate a unique id für each passed node
- * @param file  - the path to the file this AST was extracted from will be added to the nodes
  * @typeParam OtherInfo - The original decoration of the ast nodes (probably is nothing as the id decoration is most likely the first step to be performed after extraction)
  * @returns A decorated AST based on the input and the id provider.
  */
-export declare function decorateAst<OtherInfo = NoInfo>(ast: RNode<OtherInfo>, { getId, file }: NormalizedAstDecorationConfiguration<OtherInfo>): NormalizedAst<OtherInfo & ParentInformation>;
+export declare function decorateAst<OtherInfo = NoInfo>(project: RProject<OtherInfo>, { getId }: NormalizedAstDecorationConfiguration<OtherInfo>): NormalizedAst<OtherInfo & ParentInformation>;

package/r-bridge/lang-4.x/ast/model/processing/decorate.js

@@ -58,7 +58,7 @@ function nodeToLocationId(data) {
  */
 function deterministicLocationIdGenerator(start = 0) {
     let id = start;
-    return (data) => data.location !== undefined ? nodeToLocationId(data) : `${id++}`;
+    return (data) => 'location' in data && data.location !== undefined ? nodeToLocationId(data) : `${id++}`;
 }
 const defaultParentContext = {
     role: "root" /* RoleInParent.Root */,
@@ -69,21 +69,19 @@ const nestForElement = new Set([
 ]);
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
- * @param ast   - The root of the AST to convert
+ * @param project - The AST to decorate
  * @param getId - The id generator: must generate a unique id für each passed node
- * @param file  - the path to the file this AST was extracted from will be added to the nodes
  * @typeParam OtherInfo - The original decoration of the ast nodes (probably is nothing as the id decoration is most likely the first step to be performed after extraction)
  * @returns A decorated AST based on the input and the id provider.
  */
-function decorateAst(ast, { getId = deterministicCountingIdGenerator(0), file }) {
+function decorateAst(project, { getId = deterministicCountingIdGenerator(0) }) {
     const idMap = new bimap_1.BiMap();
-    const info = { idMap, getId, file };
+    const info = { idMap, getId, file: undefined };
     /* Please note, that all fold processors do not re-create copies in higher-folding steps so that the idMap stays intact. */
     const foldLeaf = createFoldForLeaf(info);
     const foldBinaryOp = createFoldForBinaryOp(info);
     const unaryOp = createFoldForUnaryOp(info);
-    /* we pass down the nesting depth */
-    const decoratedAst = (0, stateful_fold_1.foldAstStateful)(ast, 0, {
+    const folds = {
         down: (n, nesting) => {
             if (nestForElement.has(n.type)) {
                 return nesting + 1;
@@ -119,11 +117,26 @@ function decorateAst(ast, { getId = deterministicCountingIdGenerator(0), file })
             foldArgument: createFoldForFunctionArgument(info),
             foldParameter: createFoldForFunctionParameter(info)
         }
-    });
-    decoratedAst.info.role = "root" /* RoleInParent.Root */;
-    decoratedAst.info.index = 0;
+    };
+    // we return the project by mapping over the files
+    const decoratedProject = {
+        ...project,
+        files: project.files.map(file => {
+            info.file = file.filePath;
+            const decoratedAst = (0, stateful_fold_1.foldAstStateful)(file.root, 0, folds);
+            decoratedAst.info.role = "root" /* RoleInParent.Root */;
+            decoratedAst.info.index = 0;
+            return {
+                root: decoratedAst,
+                filePath: file.filePath
+            };
+        }),
+        info: {
+            id: getId(project)
+        }
+    };
     return {
-        ast: decoratedAst,
+        ast: decoratedProject,
         idMap
     };
 }

package/r-bridge/lang-4.x/ast/model/type.d.ts

@@ -197,6 +197,8 @@ export declare enum RType {
     String = "RString",
     /** {@link RSymbol} */
     Symbol = "RSymbol",
+    /** {@link RProject} */
+    Project = "RProject",
     /**
      * {@link RDelimiter}.
      * Is not part of the normalized AST but can be found in

package/r-bridge/lang-4.x/ast/model/type.js

@@ -204,6 +204,8 @@ var RType;
     /** {@link RSymbol} */
     RType["Symbol"] = "RSymbol";
     /* ------ special types ------ */
+    /** {@link RProject} */
+    RType["Project"] = "RProject";
     /**
      * {@link RDelimiter}.
      * Is not part of the normalized AST but can be found in

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -61,7 +61,7 @@ function convertPreparedParsedData(roots) {
         };
     }
     // Locate start, end of a source file (order children in advance).
-    const rootEntries = [...roots].sort(orderOf);
+    const rootEntries = roots.slice().sort(orderOf);
     const start = rootEntries[0];
     const end = rootEntries[rootEntries.length - 1];
     // Construct CsvEntry for the root, handling empty input.

package/r-bridge/lang-4.x/ast/parser/json/parser.d.ts

@@ -1,21 +1,22 @@
 import { type IdGenerator, type NormalizedAst } from '../../model/processing/decorate';
-import type { NoInfo, RNode } from '../../model/model';
-import type { ParseStepOutput } from '../../../../parser';
+import type { NoInfo } from '../../model/model';
+import type { ParseStepOutput, ParseStepOutputSingleFile } from '../../../../parser';
 import { type FlowrConfigOptions } from '../../../../../config';
 import type { Tree } from 'web-tree-sitter';
+import type { RProject } from '../../model/nodes/r-project';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
- * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
- * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
+ * @see {@link normalizeButNotDecorated} - for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter}      - for a version that normalizes the AST from the TreeSitter parser
  */
-export declare function normalize(parsed: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;
+export declare function normalize(parsed: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>): NormalizedAst;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
- * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ * For additional decoration with {@link decorateAst} use {@link normalize}.
  */
-export declare function normalizeButNotDecorated({ parsed }: ParseStepOutput<string>): RNode;
+export declare function normalizeButNotDecorated({ parsed, filePath }: ParseStepOutputSingleFile<string>): RProject;
 /**
  * Tree-Sitter pendant to {@link normalize}.
  */
-export declare function normalizeTreeSitter({ parsed }: ParseStepOutput<Tree>, getId: IdGenerator<NoInfo> | undefined, config: FlowrConfigOptions, file?: string): NormalizedAst;
+export declare function normalizeTreeSitter(parsed: ParseStepOutput<Tree>, getId: IdGenerator<NoInfo> | undefined, config: FlowrConfigOptions): NormalizedAst;

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -10,31 +10,32 @@ const decorate_1 = require("../../model/processing/decorate");
 const normalize_root_1 = require("../main/internal/structure/normalize-root");
 const tree_sitter_normalize_1 = require("../../../tree-sitter/tree-sitter-normalize");
 const config_1 = require("../../../../../config");
+const r_project_1 = require("../../model/nodes/r-project");
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
- * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
- * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
+ * @see {@link normalizeButNotDecorated} - for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter}      - for a version that normalizes the AST from the TreeSitter parser
  */
-function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
-    return (0, decorate_1.decorateAst)(normalizeButNotDecorated(parsed), { getId, file });
+function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0)) {
+    return (0, decorate_1.decorateAst)((0, r_project_1.mergeProjects)(parsed.files.map(normalizeButNotDecorated)), { getId });
 }
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
- * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ * For additional decoration with {@link decorateAst} use {@link normalize}.
  */
-function normalizeButNotDecorated({ parsed }) {
+function normalizeButNotDecorated({ parsed, filePath }) {
     const data = { currentRange: undefined, currentLexeme: undefined };
     const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(parsed));
-    return (0, normalize_root_1.normalizeRootObjToAst)(data, object);
+    return (0, normalize_root_1.normalizeRootObjToAst)(data, object, filePath);
 }
 /**
  * Tree-Sitter pendant to {@link normalize}.
  */
-function normalizeTreeSitter({ parsed }, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), config, file) {
+function normalizeTreeSitter(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), config) {
     const lax = (0, config_1.getEngineConfig)(config, 'tree-sitter')?.lax;
-    const result = (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed, lax), { getId, file });
-    result.hasError = parsed.rootNode.hasError;
+    const result = (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed.files, lax), { getId });
+    result.hasError = parsed.files.some(p => p.parsed.rootNode.hasError);
     return result;
 }
 //# sourceMappingURL=parser.js.map

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.d.ts

@@ -1,7 +1,8 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { RExpressionList } from '../../../../model/nodes/r-expression-list';
 import type { JsonEntry } from '../../../json/format';
+import type { RProject } from '../../../../model/nodes/r-project';
 /**
- * Takes the parse dta as object and produces an undecorated, normalized AST.
+ * Takes the parse data as object and produces an undecorated, normalized AST.
+ * @see {@link normalize} - for a version that also decorates the AST
  */
-export declare function normalizeRootObjToAst(data: NormalizerData, obj: JsonEntry): RExpressionList;
+export declare function normalizeRootObjToAst(data: NormalizerData, obj: JsonEntry, filePath?: string): RProject;

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.js

@@ -7,9 +7,10 @@ const log_1 = require("../../../../../../../util/log");
 const arrays_1 = require("../../../../../../../util/collections/arrays");
 const type_1 = require("../../../../model/type");
 /**
- * Takes the parse dta as object and produces an undecorated, normalized AST.
+ * Takes the parse data as object and produces an undecorated, normalized AST.
+ * @see {@link normalize} - for a version that also decorates the AST
  */
-function normalizeRootObjToAst(data, obj) {
+function normalizeRootObjToAst(data, obj, filePath) {
     const exprContent = obj.token;
     (0, normalize_meta_1.assureTokenType)(exprContent, type_1.RawRType.ExpressionList);
     let parsedChildren = [];
@@ -22,15 +23,23 @@ function normalizeRootObjToAst(data, obj) {
     }
     const [delimiters, nodes] = (0, arrays_1.partition)(parsedChildren, x => x.type === type_1.RType.Delimiter || x.type === type_1.RType.Comment);
     return {
-        type: type_1.RType.ExpressionList,
-        children: nodes,
-        grouping: undefined,
-        lexeme: undefined,
-        info: {
-            fullRange: data.currentRange,
-            additionalTokens: delimiters,
-            fullLexeme: data.currentLexeme
-        }
+        type: type_1.RType.Project,
+        files: [
+            {
+                filePath,
+                root: {
+                    type: type_1.RType.ExpressionList,
+                    children: nodes,
+                    grouping: undefined,
+                    lexeme: undefined,
+                    info: {
+                        fullRange: data.currentRange,
+                        additionalTokens: delimiters,
+                        fullLexeme: data.currentLexeme
+                    }
+                }
+            }
+        ]
     };
 }
 //# sourceMappingURL=normalize-root.js.map

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
+                };
+            })
         };
     }
 }