@eagleoutice/flowr 2.6.1 → 2.6.3

package/queries/query.js

@@ -10,16 +10,17 @@ 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");
 const dataflow_query_format_1 = require("./catalog/dataflow-query/dataflow-query-format");
 const id_map_query_format_1 = require("./catalog/id-map-query/id-map-query-format");
 const normalized_ast_query_format_1 = require("./catalog/normalized-ast-query/normalized-ast-query-format");
-const lineage_query_format_1 = require("./catalog/lineage-query/lineage-query-format");
 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");
@@ -33,6 +34,7 @@ const linter_query_format_1 = require("./catalog/linter-query/linter-query-forma
 const control_flow_query_format_1 = require("./catalog/control-flow-query/control-flow-query-format");
 const df_shape_query_format_1 = require("./catalog/df-shape-query/df-shape-query-format");
 const inspect_higher_order_query_format_1 = require("./catalog/inspect-higher-order-query/inspect-higher-order-query-format");
+const log_1 = require("../util/log");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -44,7 +46,6 @@ exports.SupportedQueries = {
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,
     'static-slice': static_slice_query_format_1.StaticSliceQueryDefinition,
-    'lineage': lineage_query_format_1.LineageQueryDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
     'search': search_query_format_1.SearchQueryDefinition,
@@ -55,6 +56,11 @@ exports.SupportedQueries = {
     'origin': origin_query_format_1.OriginQueryDefinition,
     'linter': linter_query_format_1.LinterQueryDefinition
 };
+/**
+ * Executes a set of queries that are all of the same type.
+ * Only use this function if you are sure all queries are of the same type.
+ * Otherwise, use {@link executeQueries}.
+ */
 async function executeQueriesOfSameType(data, queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');
     /* every query must have the same type */
@@ -86,35 +92,34 @@ function groupQueriesByType(queries) {
     }
     return grouped;
 }
-function isPromiseLike(value) {
-    return value !== null && typeof value === 'object' && typeof value.then === 'function';
-}
 /**
  * This is the main query execution function that takes a set of queries and executes them on the given data.
+ * @see {@link executeQueriesOfSameType}
  */
-function executeQueries(data, queries) {
+async function executeQueries(data, queries) {
     const now = Date.now();
     const grouped = groupQueriesByType(queries);
     const entries = Object.entries(grouped);
-    const results = entries.map(([type, group]) => [type, executeQueriesOfSameType(data, group)]);
-    if (results.length === 0 || results.every(([_, r]) => !isPromiseLike(r))) {
-        // all results are synchronous, we can return them directly
-        const r = Object.fromEntries(results);
-        r['.meta'] = {
-            timing: Date.now() - now
-        };
-        return r;
+    const results = [];
+    for (const [type, group] of entries) {
+        try {
+            const result = await Promise.resolve(executeQueriesOfSameType(data, group));
+            results.push([type, result]);
+        }
+        catch (e) {
+            log_1.log.warn(e);
+            results.push([type, undefined]);
+        }
     }
-    return Promise.all(results.map(([type, result]) => Promise.resolve(result).then(resolvedResult => [type, resolvedResult]).catch(() => {
-        return [type, undefined];
-    }))).then(resultsArray => {
-        const results = Object.fromEntries(resultsArray);
-        results['.meta'] = {
-            timing: Date.now() - now
-        };
-        return results;
-    });
+    const r = Object.fromEntries(results);
+    r['.meta'] = {
+        timing: Date.now() - now
+    };
+    return r;
 }
+/**
+ * Produces a Joi schema representing all supported queries.
+ */
 function SupportedQueriesSchema() {
     return joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
 }
@@ -124,13 +129,40 @@ exports.CompoundQuerySchema = joi_1.default.object({
     commonArguments: joi_1.default.object().required().description('Common arguments for all queries.'),
     arguments: joi_1.default.array().items(joi_1.default.object()).required().description('Arguments for each query.')
 }).description('Compound query used to combine queries of the same type');
+/**
+ * Produces a Joi schema representing all virtual queries.
+ */
 function VirtualQuerySchema() {
     return joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
 }
+/**
+ * Produces a Joi schema representing any supported query (including virtual queries).
+ */
 function AnyQuerySchema() {
     return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
 }
+/**
+ * Produces a Joi schema representing an array of supported queries.
+ */
 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/queries/virtual-query/virtual-queries.d.ts

@@ -1,6 +1,5 @@
 import type { QueryArgumentsWithType, SupportedQueryTypes } from '../query';
-import type { CompoundQueryFormat, VirtualCompoundConstraint } from './compound-query';
-import { executeCompoundQueries } from './compound-query';
+import { type CompoundQueryFormat, type VirtualCompoundConstraint, executeCompoundQueries } from './compound-query';
 import type { BaseQueryFormat } from '../base-query-format';
 /** A query that does not perform a search but may perform (e.g., convenience) modifications of other queries */
 export type VirtualQueryArgumentsWithType<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = CompoundQueryFormat<Base, VirtualArguments>;

package/r-bridge/data/get.d.ts

@@ -14,6 +14,12 @@ type PathToCapability = readonly number[];
 export interface FlowrCapabilityWithPath extends FlowrCapability {
     path: PathToCapability;
 }
+/**
+ * Find a flowR capability by its id.
+ */
 export declare function getCapabilityById(id: FlowrCapabilityId): FlowrCapabilityWithPath;
+/**
+ * Get all capabilities with their paths.
+ */
 export declare function getAllCapabilities(): readonly FlowrCapabilityWithPath[];
 export {};

package/r-bridge/data/get.js

@@ -21,6 +21,9 @@ function search(id, capabilities, path = []) {
     return undefined;
 }
 const capabilityCache = new Map();
+/**
+ * Find a flowR capability by its id.
+ */
 function getCapabilityById(id) {
     const cached = capabilityCache.get(id);
     if (cached) {
@@ -31,6 +34,9 @@ function getCapabilityById(id) {
     capabilityCache.set(id, value);
     return value;
 }
+/**
+ * Get all capabilities with their paths.
+ */
 function getAllCapabilities() {
     const result = [];
     function traverse(capabilities, currentPath = []) {

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

@@ -1,10 +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,13 +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/model.d.ts

@@ -31,16 +31,16 @@ export type NoInfo = object;
  */
 interface Source {
     /**
-   * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
-   * element.
-   * <p>
-   * As an example for the difference, consider a for loop, the location of `for` will be just the three characters,
-   * but the *range* will be everything including the loop body.
-   */
+     * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
+     * element.
+     * <p>
+     * As an example for the difference, consider a for loop, the location of `for` will be just the three characters,
+     * but the *range* will be everything including the loop body.
+     */
     fullRange?: SourceRange;
     /**
-   * Similar to {@link Source.fullRange} this contains the complete R lexeme of the given element.
-   */
+     * Similar to {@link Source.fullRange} this contains the complete R lexeme of the given element.
+     */
     fullLexeme?: string;
     /**
      * This may contain additional elements that were part of the original R code, but are not part of the normalized R-ast.
@@ -54,7 +54,6 @@ interface Source {
 }
 /**
  * Provides the common base of all {@link RNode|RNodes}.
- *
  * @typeParam Info       - can be used to store additional information about the node
  * @typeParam LexemeType - the type of the lexeme, probably always a `string` or `string | undefined`
  */
@@ -85,7 +84,6 @@ export interface Location {
     /**
      * The location may differ from what is stated in {@link Source#fullRange} as it
      * represents the location identified by the R parser.
-     *
      * @see Source#fullRange
      */
     location: SourceRange;
@@ -144,7 +142,6 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * All other subtypes (like {@link RLoopConstructs}) listed above
  * can be used to restrict the kind of node. They do not have to be
  * exclusive, some nodes can appear in multiple subtypes.
- *
  * @see {@link recoverName} - to receive the name/lexeme from such a node
  * @see {@link recoverContent} - for a more rigorous approach to get the content of a node within a {@link DataflowGraph|dataflow graph}
  */

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

@@ -6,7 +6,6 @@ export declare const EmptyArgument = "<>";
 export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
 /**
  * Calls of functions like `a()` and `foo(42, "hello")`.
- *
  * @see RUnnamedFunctionCall
  */
 export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
@@ -18,7 +17,6 @@ export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location
 }
 /**
  * Direct calls of functions like `(function(x) { x })(3)`.
- *
  * @see RNamedFunctionCall
  */
 export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {

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

@@ -10,4 +10,7 @@ export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.Number;
     content: RNumberValue;
 }
+/**
+ * Checks whether the given node is an RNumber.
+ */
 export declare function isRNumber(node: RNode | undefined): node is RNumber;

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRNumber = isRNumber;
 const type_1 = require("../type");
+/**
+ * Checks whether the given node is an RNumber.
+ */
 function isRNumber(node) {
     return node?.type === type_1.RType.Number;
 }

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/nodes/r-string.d.ts

@@ -8,4 +8,7 @@ export interface RString<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.String;
     content: RStringValue;
 }
+/**
+ *
+ */
 export declare function isRString(node: RNode | undefined): node is RString;

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRString = isRString;
 const type_1 = require("../type");
+/**
+ *
+ */
 function isRString(node) {
     return node?.type === type_1.RType.String;
 }

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

@@ -1,5 +1,8 @@
 import type { Leaf, Location, Namespace, NoInfo } from '../model';
 import type { RType } from '../type';
+/**
+ *
+ */
 export declare function isSpecialSymbol(symbol: RSymbol): boolean;
 /**
  * Represents identifiers (variables).

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSpecialSymbol = isSpecialSymbol;
 const convert_values_1 = require("../../../convert-values");
+/**
+ *
+ */
 function isSpecialSymbol(symbol) {
     return symbol.content === convert_values_1.RNull || symbol.content === convert_values_1.RNa;
 }

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

@@ -3,7 +3,6 @@ import { RawRType } from './type';
 import type { SupportedFlowrCapabilityId } from '../../../data/get';
 /**
  * Just a type-alias so that type declarations become more readable.
- *
  * @see OperatorDatabase
  */
 type StringUsedInRCode = string;

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

@@ -5,7 +5,6 @@
  * 2. transforming the AST into a doubly linked tree using the ids (so it stays serializable)
  *
  * The main entry point is {@link decorateAst}.
- *
  * @module
  */
 import type { NoInfo, RNode } from '../model';
@@ -15,29 +14,33 @@ 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.
  */
 export declare function deterministicCountingIdGenerator(id?: number): () => NodeId;
+/**
+ * Generates ids with a fixed prefix and an incrementing counter.
+ */
 export declare function deterministicPrefixIdGenerator(prefix: string, id?: number): () => NodeId;
+/**
+ *  Generates ids with a fixed source path and location information as prefix and an incrementing counter.
+ */
 export declare function sourcedDeterministicCountingIdGenerator(path: string, location: SourceRange, start?: number): () => NodeId;
 /**
  * Generates the location id, used by {@link deterministicLocationIdGenerator}.
- *
  * @param data - the node to generate an id for, must have location information
  */
 export declare function nodeToLocationId<OtherInfo>(data: RNode<OtherInfo> | RDelimiter): NodeId;
 /**
  * Generates unique ids based on the locations of the node (see {@link nodeToLocationId}).
  * If a node has no location information, it will be assigned a unique counter-value.
- *
  * @param start - the start value for the counter, in case nodes do not have location information
  */
 export declare function deterministicLocationIdGenerator<OtherInfo>(start?: number): IdGenerator<OtherInfo>;
@@ -69,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 */
@@ -80,18 +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

@@ -6,7 +6,6 @@
  * 2. transforming the AST into a doubly linked tree using the ids (so it stays serializable)
  *
  * The main entry point is {@link decorateAst}.
- *
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -27,9 +26,15 @@ const r_function_call_1 = require("../nodes/r-function-call");
 function deterministicCountingIdGenerator(id = 0) {
     return () => id++;
 }
+/**
+ * Generates ids with a fixed prefix and an incrementing counter.
+ */
 function deterministicPrefixIdGenerator(prefix, id = 0) {
     return () => `${prefix}-${id++}`;
 }
+/**
+ *  Generates ids with a fixed source path and location information as prefix and an incrementing counter.
+ */
 function sourcedDeterministicCountingIdGenerator(path, location, start = 0) {
     let id = start;
     return () => `${path}-${loc2Id(location)}-${id++}`;
@@ -39,7 +44,6 @@ function loc2Id([sl, sc, el, ec]) {
 }
 /**
  * Generates the location id, used by {@link deterministicLocationIdGenerator}.
- *
  * @param data - the node to generate an id for, must have location information
  */
 function nodeToLocationId(data) {
@@ -50,12 +54,11 @@ function nodeToLocationId(data) {
 /**
  * Generates unique ids based on the locations of the node (see {@link nodeToLocationId}).
  * If a node has no location information, it will be assigned a unique counter-value.
- *
  * @param start - the start value for the counter, in case nodes do not have location information
  */
 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 */,
@@ -66,24 +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/processing/fold.d.ts

@@ -1,6 +1,6 @@
 import type { DeepReadonly } from 'ts-essentials';
 import type { RNode } from '../model';
-import type { StatefulFoldFunctions } from './stateful-fold';
+import { type StatefulFoldFunctions } from './stateful-fold';
 export type FoldFunctions<Info, Out> = Omit<StatefulFoldFunctions<Info, undefined, Out>, 'down'>;
 /**
  * Folds in old functional-fashion over the AST structure.

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

@@ -8,7 +8,6 @@ export type NodeId<T extends string | number = string | number> = T & {
 export declare function normalizeIdToNumberIfPossible(id: NodeId): NodeId;
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
- *
  * @see {@link recoverContent} - to recover the content of a node
  */
 export declare function recoverName(id: NodeId, idMap?: AstIdMap): string | undefined;

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

@@ -16,7 +16,6 @@ function normalizeIdToNumberIfPossible(id) {
 }
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
- *
  * @see {@link recoverContent} - to recover the content of a node
  */
 function recoverName(id, idMap) {

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

@@ -2,7 +2,6 @@ import type { AstIdMap, RNodeWithParent } from './decorate';
 /**
  * Describes the role of the node in its parent. For example,
  * if we have `if(TRUE) { ... }`, the role of the `TRUE` node is `IfCondition`.
- *
  * @see ParentContextInfo
  * @see ParentInformation
  */

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

@@ -8,8 +8,7 @@ import type { RAccess } from '../nodes/r-access';
 import type { RBinaryOp } from '../nodes/r-binary-op';
 import type { RPipe } from '../nodes/r-pipe';
 import type { RUnaryOp } from '../nodes/r-unary-op';
-import type { RFunctionCall } from '../nodes/r-function-call';
-import { EmptyArgument } from '../nodes/r-function-call';
+import { type RFunctionCall, EmptyArgument } from '../nodes/r-function-call';
 import type { RForLoop } from '../nodes/r-for-loop';
 import type { RWhileLoop } from '../nodes/r-while-loop';
 import type { RRepeatLoop } from '../nodes/r-repeat-loop';

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

@@ -5,7 +5,6 @@ export type OnEnter<OtherInfo> = (node: RNode<OtherInfo>) => (boolean | void);
 export type OnExit<OtherInfo> = (node: RNode<OtherInfo>) => void;
 /**
  * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
- *
  * @param nodes          - The root id nodes to start collecting from
  * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
  * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)

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

@@ -101,7 +101,6 @@ class NodeVisitor {
 }
 /**
  * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
- *
  * @param nodes          - The root id nodes to start collecting from
  * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
  * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)