@eagleoutice/flowr 2.4.8 → 2.6.0

package/project/cache/flowr-analyzer-cache.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerCache = void 0;
+const flowr_cache_1 = require("./flowr-cache");
+const default_pipelines_1 = require("../../core/steps/pipeline/default-pipelines");
+const assert_1 = require("../../util/assert");
+const objectmap_1 = require("../../util/collections/objectmap");
+const extract_cfg_1 = require("../../control-flow/extract-cfg");
+/**
+ * This provides the full analyzer caching layer, please avoid using this directly
+ * and prefer the {@link FlowrAnalyzer}.
+ */
+class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
+    args;
+    pipeline = undefined;
+    controlFlowCache = undefined;
+    constructor(args) {
+        super();
+        this.args = args;
+        this.initCacheProviders();
+    }
+    initCacheProviders() {
+        this.pipeline = (0, default_pipelines_1.createDataflowPipeline)(this.args.parser, {
+            request: this.args.request,
+            getId: this.args.getId,
+            overwriteFilePath: this.args.overwriteFilePath
+        }, this.args.config);
+        this.controlFlowCache = {
+            simplified: new objectmap_1.ObjectMap(),
+        };
+    }
+    static create(data) {
+        return new FlowrAnalyzerCache(data);
+    }
+    receive(event) {
+        super.receive(event);
+        switch (event.type) {
+            case "full" /* CacheInvalidationEventType.Full */:
+                this.initCacheProviders();
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(event.type);
+        }
+    }
+    get() {
+        /* this will do a ref assignment, so indirect force */
+        return this.computeIfAbsent(false, () => this.pipeline.getResults(true));
+    }
+    reset() {
+        this.receive({ type: "full" /* CacheInvalidationEventType.Full */ });
+    }
+    async runTapeUntil(force, until) {
+        if (force) {
+            this.reset();
+        }
+        let g;
+        while ((g = until()) === undefined && this.pipeline.hasNextStep()) {
+            await this.pipeline.nextStep();
+        }
+        (0, assert_1.guard)(g !== undefined, 'Could not reach the desired pipeline step, invalid cache state(?)');
+        return g;
+    }
+    /**
+     * Get the parse output for the request, parsing if necessary.
+     * @param force - Do not use the cache, instead force a new parse.
+     *
+     * @see {@link FlowrAnalyzerCache#peekParse} - to get the parse output if already available without triggering a new parse.
+     */
+    async parse(force) {
+        const d = this.get();
+        return this.runTapeUntil(force, () => d.parse);
+    }
+    /**
+     * Get the parse output for the request if already available, otherwise return `undefined`.
+     * This will not trigger a new parse.
+     *
+     * @see {@link FlowrAnalyzerCache#parse} - to get the parse output, parsing if necessary.
+     */
+    peekParse() {
+        return this.get().parse;
+    }
+    /**
+     * Get the normalized abstract syntax tree for the request, normalizing if necessary.
+     * @param force - Do not use the cache, instead force new analyses.
+     * @see {@link FlowrAnalyzerCache#peekNormalize} - to get the normalized AST if already available without triggering a new normalization.
+     */
+    async normalize(force) {
+        const d = this.get();
+        return this.runTapeUntil(force, () => d.normalize);
+    }
+    /**
+     * Get the normalized abstract syntax tree for the request if already available, otherwise return `undefined`.
+     * This will not trigger a new normalization.
+     *
+     * @see {@link FlowrAnalyzerCache#normalize} - to get the normalized AST, normalizing if necessary.
+     */
+    peekNormalize() {
+        return this.get().normalize;
+    }
+    /**
+     * Get the dataflow graph for the request, computing if necessary.
+     * @param force - Do not use the cache, instead force new analyses.
+     *
+     * @see {@link FlowrAnalyzerCache#peekDataflow} - to get the dataflow graph if already available without triggering a new computation.
+     */
+    async dataflow(force) {
+        const d = this.get();
+        return this.runTapeUntil(force, () => d.dataflow);
+    }
+    /**
+     * Get the dataflow graph for the request if already available, otherwise return `undefined`.
+     * This will not trigger a new computation.
+     *
+     * @see {@link FlowrAnalyzerCache#dataflow} - to get the dataflow graph, computing if necessary.
+     */
+    peekDataflow() {
+        return this.get().dataflow;
+    }
+    /**
+     * Get the control flow graph (CFG) for the request, computing if necessary.
+     * @param force - Do not use the cache, instead force new analyses.
+     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param simplifications - Simplification passes to be applied to the CFG.
+     */
+    async controlflow(force, useDataflow, simplifications) {
+        simplifications ??= [];
+        if (!force) {
+            const value = this.controlFlowCache.simplified.get([simplifications, useDataflow]);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        const normalized = await this.normalize(force);
+        let dataflow = undefined;
+        if (useDataflow) {
+            /* if force is active, it will have triggered with normalize */
+            dataflow = await this.dataflow();
+        }
+        const result = simplifications.length === 0 && !useDataflow ? (0, extract_cfg_1.extractCfgQuick)(normalized) :
+            (0, extract_cfg_1.extractCfg)(normalized, this.args.config, dataflow?.graph, simplifications);
+        this.controlFlowCache.simplified.set([simplifications, useDataflow], result);
+        return result;
+    }
+    /**
+     * Get the control flow graph (CFG) for the request if already available, otherwise return `undefined`.
+     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param simplifications - Simplification passes to be applied to the CFG.
+     *
+     * @see {@link FlowrAnalyzerCache#controlflow} - to get the control flow graph, computing if necessary.
+     */
+    peekControlflow(useDataflow, simplifications) {
+        return this.controlFlowCache.simplified.get([simplifications ?? [], useDataflow]);
+    }
+}
+exports.FlowrAnalyzerCache = FlowrAnalyzerCache;
+//# sourceMappingURL=flowr-analyzer-cache.js.map

package/project/cache/flowr-cache.d.ts

@@ -0,0 +1,28 @@
+export declare const enum CacheInvalidationEventType {
+    Full = "full"
+}
+export type CacheInvalidationEvent = {
+    type: CacheInvalidationEventType.Full;
+};
+export interface CacheInvalidationEventReceiver {
+    receive(event: CacheInvalidationEvent): void;
+}
+/**
+ * Central class for caching analysis results in FlowR.
+ */
+export declare abstract class FlowrCache<Cache> implements CacheInvalidationEventReceiver {
+    private value;
+    private dependents;
+    registerDependent(dependent: CacheInvalidationEventReceiver): void;
+    removeDependent(dependent: CacheInvalidationEventReceiver): void;
+    receive(event: CacheInvalidationEvent): void;
+    /**
+     * Notify all dependents of a cache invalidation event.
+     */
+    notifyDependents(event: CacheInvalidationEvent): void;
+    /**
+     * Get the cached value or compute it if not present.
+     * This will, by default, not trigger any {@link notifyDependents} calls, as this is only a cache retrieval.
+     */
+    protected computeIfAbsent(force: boolean | undefined, compute: () => Cache): Cache;
+}

package/project/cache/flowr-cache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrCache = void 0;
+const assert_1 = require("../../util/assert");
+/**
+ * Central class for caching analysis results in FlowR.
+ */
+class FlowrCache {
+    value = undefined;
+    dependents = [];
+    registerDependent(dependent) {
+        this.dependents.push(dependent);
+    }
+    removeDependent(dependent) {
+        this.dependents = this.dependents.filter(d => d !== dependent);
+    }
+    receive(event) {
+        /* we will update this as soon as we support incremental update patterns */
+        switch (event.type) {
+            case "full" /* CacheInvalidationEventType.Full */:
+                this.value = undefined;
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(event.type);
+        }
+        /* in the future we want to defer this *after* the dataflow is re-computed, then all receivers can decide whether they need to update */
+        this.notifyDependents(event);
+    }
+    /**
+     * Notify all dependents of a cache invalidation event.
+     */
+    notifyDependents(event) {
+        for (const dependent of this.dependents) {
+            dependent.receive(event);
+        }
+    }
+    /**
+     * Get the cached value or compute it if not present.
+     * This will, by default, not trigger any {@link notifyDependents} calls, as this is only a cache retrieval.
+     */
+    computeIfAbsent(force, compute) {
+        if (this.value === undefined || force) {
+            this.value = compute();
+        }
+        return this.value;
+    }
+}
+exports.FlowrCache = FlowrCache;
+//# sourceMappingURL=flowr-cache.js.map

package/project/context/abstract-flowr-analyzer-context.d.ts

@@ -0,0 +1,35 @@
+import type { FlowrAnalyzerPlugin } from '../plugins/flowr-analyzer-plugin';
+import type { FlowrAnalyzerContext } from './flowr-analyzer-context';
+/**
+ * Abstract class representing the context, a context may be modified and enriched by plugins (see {@link FlowrAnalyzerPlugin}).
+ *
+ * Please use the specialized contexts like {@link FlowrAnalyzerFilesContext} or {@link FlowrAnalyzerLoadingOrderContext} to work with flowR and
+ * in general, use the {@link FlowrAnalyzerContext} to access the full project context.
+ */
+export declare abstract class AbstractFlowrAnalyzerContext<In, Out, Plugin extends FlowrAnalyzerPlugin<In, Out>> {
+    /**
+     * A human-readable name of the context. Try to make it unique to avoid confusion in the logs.
+     */
+    abstract readonly name: string;
+    /**
+     * The plugins registered for this context. These build the foundation for {@link applyPlugins}.
+     */
+    protected readonly plugins: readonly Plugin[];
+    /**
+     * The linked full project context, allowing plugins to modify and access it.
+     */
+    protected readonly ctx: FlowrAnalyzerContext;
+    /**
+     * Creates a new context with the given project context, a default plugin (to be used when no other is registered)
+     */
+    protected constructor(ctx: FlowrAnalyzerContext, defaultPlugin: Plugin, plugins?: readonly Plugin[]);
+    /**
+     * Run all registered plugins on the given args, please be aware that if they are async, it is up to you to
+     * await them.
+     */
+    protected applyPlugins(args: Parameters<Plugin['processor']>[1]): Out[];
+    /**
+     * Returns the project context this sub-context is attached to
+     */
+    getAttachedContext(): FlowrAnalyzerContext;
+}

package/project/context/abstract-flowr-analyzer-context.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractFlowrAnalyzerContext = void 0;
+const assert_1 = require("../../util/assert");
+/**
+ * Abstract class representing the context, a context may be modified and enriched by plugins (see {@link FlowrAnalyzerPlugin}).
+ *
+ * Please use the specialized contexts like {@link FlowrAnalyzerFilesContext} or {@link FlowrAnalyzerLoadingOrderContext} to work with flowR and
+ * in general, use the {@link FlowrAnalyzerContext} to access the full project context.
+ */
+class AbstractFlowrAnalyzerContext {
+    /**
+     * The plugins registered for this context. These build the foundation for {@link applyPlugins}.
+     */
+    plugins;
+    /**
+     * The linked full project context, allowing plugins to modify and access it.
+     */
+    ctx;
+    /**
+     * Creates a new context with the given project context, a default plugin (to be used when no other is registered)
+     */
+    constructor(ctx, defaultPlugin, plugins) {
+        this.plugins = [...plugins ?? [], defaultPlugin];
+        this.ctx = ctx;
+    }
+    /**
+     * Run all registered plugins on the given args, please be aware that if they are async, it is up to you to
+     * await them.
+     */
+    applyPlugins(args) {
+        const res = [];
+        for (const plugin of this.plugins) {
+            res.push(plugin.processor(this.ctx, args));
+        }
+        return res.filter(assert_1.isNotUndefined);
+    }
+    /**
+     * Returns the project context this sub-context is attached to
+     */
+    getAttachedContext() {
+        return this.ctx;
+    }
+}
+exports.AbstractFlowrAnalyzerContext = AbstractFlowrAnalyzerContext;
+//# sourceMappingURL=abstract-flowr-analyzer-context.js.map

package/project/context/flowr-analyzer-context.d.ts

@@ -0,0 +1,48 @@
+import type { RAnalysisRequest, ReadOnlyFlowrAnalyzerFilesContext } from './flowr-analyzer-files-context';
+import { FlowrAnalyzerFilesContext } from './flowr-analyzer-files-context';
+import type { ReadOnlyFlowrAnalyzerDependenciesContext } from './flowr-analyzer-dependencies-context';
+import { FlowrAnalyzerDependenciesContext } from './flowr-analyzer-dependencies-context';
+import type { FlowrAnalyzerPlugin } from '../plugins/flowr-analyzer-plugin';
+import { PluginType } from '../plugins/flowr-analyzer-plugin';
+/**
+ * This is a read-only interface to the {@link FlowrAnalyzerContext}.
+ * It prevents you from modifying the context, but allows you to inspect it (which is probably what you want when using the {@link FlowrAnalyzer}).
+ * If you are a {@link FlowrAnalyzerPlugin} and want to modify the context, you can use the {@link FlowrAnalyzerContext} directly.
+ */
+export interface ReadOnlyFlowrAnalyzerContext {
+    /**
+     * The files context provides access to the files to be analyzed and their loading order.
+     */
+    readonly files: ReadOnlyFlowrAnalyzerFilesContext;
+    /**
+     * The dependencies context provides access to the identified dependencies and their versions.
+     */
+    readonly deps: ReadOnlyFlowrAnalyzerDependenciesContext;
+}
+/**
+ * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
+ * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
+ * to get an idea of the capabilities provided by this context.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
+ * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
+ *
+ * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
+ * {@link deps.getDependency}.
+ * If you are just interested in inspecting the context, you can use {@link ReadOnlyFlowrAnalyzerContext} instead (e.g., via {@link inspect}).
+ */
+export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContext {
+    readonly files: FlowrAnalyzerFilesContext;
+    readonly deps: FlowrAnalyzerDependenciesContext;
+    constructor(plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
+    /** delegate request addition */
+    addRequests(requests: readonly RAnalysisRequest[]): void;
+    /** this conducts all the step that can be done before the main analysis run */
+    resolvePreAnalysis(): void;
+    /**
+     * Get a read-only version of this context.
+     * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce
+     * the available methods.
+     */
+    inspect(): ReadOnlyFlowrAnalyzerContext;
+}

package/project/context/flowr-analyzer-context.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerContext = void 0;
+const flowr_analyzer_files_context_1 = require("./flowr-analyzer-files-context");
+const flowr_analyzer_dependencies_context_1 = require("./flowr-analyzer-dependencies-context");
+const flowr_analyzer_plugin_1 = require("../plugins/flowr-analyzer-plugin");
+const flowr_analyzer_loading_order_context_1 = require("./flowr-analyzer-loading-order-context");
+/**
+ * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
+ * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
+ * to get an idea of the capabilities provided by this context.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
+ * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
+ *
+ * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
+ * {@link deps.getDependency}.
+ * If you are just interested in inspecting the context, you can use {@link ReadOnlyFlowrAnalyzerContext} instead (e.g., via {@link inspect}).
+ */
+class FlowrAnalyzerContext {
+    files;
+    deps;
+    constructor(plugins) {
+        const loadingOrder = new flowr_analyzer_loading_order_context_1.FlowrAnalyzerLoadingOrderContext(this, plugins.get(flowr_analyzer_plugin_1.PluginType.LoadingOrder));
+        this.files = new flowr_analyzer_files_context_1.FlowrAnalyzerFilesContext(loadingOrder, (plugins.get(flowr_analyzer_plugin_1.PluginType.ProjectDiscovery) ?? []), (plugins.get(flowr_analyzer_plugin_1.PluginType.FileLoad) ?? []));
+        this.deps = new flowr_analyzer_dependencies_context_1.FlowrAnalyzerDependenciesContext(this, (plugins.get(flowr_analyzer_plugin_1.PluginType.DependencyIdentification) ?? []));
+    }
+    /** delegate request addition */
+    addRequests(requests) {
+        this.files.addRequests(requests);
+    }
+    /** this conducts all the step that can be done before the main analysis run */
+    resolvePreAnalysis() {
+        this.files.computeLoadingOrder();
+        this.deps.resolveStaticDependencies();
+    }
+    /**
+     * Get a read-only version of this context.
+     * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce
+     * the available methods.
+     */
+    inspect() {
+        return this;
+    }
+}
+exports.FlowrAnalyzerContext = FlowrAnalyzerContext;
+//# sourceMappingURL=flowr-analyzer-context.js.map

package/project/context/flowr-analyzer-dependencies-context.d.ts

@@ -0,0 +1,38 @@
+import { AbstractFlowrAnalyzerContext } from './abstract-flowr-analyzer-context';
+import { FlowrAnalyzerPackageVersionsPlugin } from '../plugins/package-version-plugins/flowr-analyzer-package-versions-plugin';
+import type { Package } from '../plugins/package-version-plugins/package';
+import type { FlowrAnalyzerContext } from './flowr-analyzer-context';
+/**
+ * This is a read-only interface to the {@link FlowrAnalyzerDependenciesContext}.
+ * It prevents you from modifying the dependencies, but allows you to inspect them (which is probably what you want when using the {@link FlowrAnalyzer}).
+ * If you are a {@link FlowrAnalyzerPackageVersionsPlugin} and want to modify the dependencies, you can use the {@link FlowrAnalyzerDependenciesContext} directly.
+ */
+export interface ReadOnlyFlowrAnalyzerDependenciesContext {
+    /**
+     * The name of this context.
+     */
+    readonly name: string;
+    /**
+     * Get the dependency with the given name, if it exists.
+     *
+     * If the static dependencies have not yet been loaded, this may trigger a resolution step.
+     *
+     * @param name - The name of the dependency to get.
+     * @returns The dependency with the given name, or undefined if it does not exist.
+     */
+    getDependency(name: string): Package | undefined;
+}
+/**
+ * This context is responsible for managing the dependencies of the project, including their versions and interplays with {@link FlowrAnalyzerPackageVersionsPlugin}s.
+ *
+ * If you are interested in inspecting these dependencies, refer to {@link ReadOnlyFlowrAnalyzerDependenciesContext}.
+ */
+export declare class FlowrAnalyzerDependenciesContext extends AbstractFlowrAnalyzerContext<undefined, void, FlowrAnalyzerPackageVersionsPlugin> implements ReadOnlyFlowrAnalyzerDependenciesContext {
+    readonly name = "flowr-analyzer-dependencies-context";
+    private dependencies;
+    private staticsLoaded;
+    constructor(ctx: FlowrAnalyzerContext, plugins?: readonly FlowrAnalyzerPackageVersionsPlugin[]);
+    resolveStaticDependencies(): void;
+    addDependency(pkg: Package): void;
+    getDependency(name: string): Package | undefined;
+}

package/project/context/flowr-analyzer-dependencies-context.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerDependenciesContext = void 0;
+const abstract_flowr_analyzer_context_1 = require("./abstract-flowr-analyzer-context");
+const flowr_analyzer_package_versions_plugin_1 = require("../plugins/package-version-plugins/flowr-analyzer-package-versions-plugin");
+/**
+ * This context is responsible for managing the dependencies of the project, including their versions and interplays with {@link FlowrAnalyzerPackageVersionsPlugin}s.
+ *
+ * If you are interested in inspecting these dependencies, refer to {@link ReadOnlyFlowrAnalyzerDependenciesContext}.
+ */
+class FlowrAnalyzerDependenciesContext extends abstract_flowr_analyzer_context_1.AbstractFlowrAnalyzerContext {
+    name = 'flowr-analyzer-dependencies-context';
+    dependencies = new Map();
+    staticsLoaded = false;
+    constructor(ctx, plugins) {
+        super(ctx, flowr_analyzer_package_versions_plugin_1.FlowrAnalyzerPackageVersionsPlugin.defaultPlugin(), plugins);
+    }
+    resolveStaticDependencies() {
+        this.applyPlugins(undefined);
+        this.staticsLoaded = true;
+    }
+    addDependency(pkg) {
+        const p = this.dependencies.get(pkg.name);
+        if (p) {
+            p.mergeInPlace(pkg);
+        }
+        else {
+            this.dependencies.set(pkg.name, pkg);
+        }
+    }
+    getDependency(name) {
+        if (!this.staticsLoaded) {
+            this.resolveStaticDependencies();
+        }
+        return this.dependencies.get(name);
+    }
+}
+exports.FlowrAnalyzerDependenciesContext = FlowrAnalyzerDependenciesContext;
+//# sourceMappingURL=flowr-analyzer-dependencies-context.js.map

package/project/context/flowr-analyzer-files-context.d.ts

@@ -0,0 +1,86 @@
+import { AbstractFlowrAnalyzerContext } from './abstract-flowr-analyzer-context';
+import type { RParseRequest, RParseRequestFromFile } from '../../r-bridge/retriever';
+import type { FlowrAnalyzerLoadingOrderContext, ReadOnlyFlowrAnalyzerLoadingOrderContext } from './flowr-analyzer-loading-order-context';
+import { FlowrAnalyzerProjectDiscoveryPlugin } from '../plugins/project-discovery/flowr-analyzer-project-discovery-plugin';
+import { FlowrAnalyzerFilePlugin } from '../plugins/file-plugins/flowr-analyzer-file-plugin';
+import type { FlowrFile, FlowrFileProvider } from './flowr-file';
+import { SpecialFileRole } from './flowr-file';
+import type { FlowrDescriptionFile } from '../plugins/file-plugins/flowr-description-file';
+/**
+ * This is a request to process a folder as a project, which will be expanded by the registered {@link FlowrAnalyzerProjectDiscoveryPlugin}s.
+ */
+export interface RProjectAnalysisRequest {
+    readonly request: 'project';
+    /**
+     * The path to the root folder (an absolute path is probably best here).
+     */
+    readonly content: string;
+}
+export type RAnalysisRequest = RParseRequest | RProjectAnalysisRequest;
+export type SpecialFiles = {
+    [SpecialFileRole.Description]: FlowrDescriptionFile[];
+    [SpecialFileRole.Namespace]: FlowrFileProvider[];
+    [SpecialFileRole.Data]: FlowrFileProvider[];
+    [SpecialFileRole.Other]: FlowrFileProvider[];
+};
+/**
+ * This is the read-only interface for the files context, which is used to manage all files known to the {@link FlowrAnalyzer}.
+ * It prevents you from modifying the available files, but allows you to inspect them (which is probably what you want when using the {@link FlowrAnalyzer}).
+ * If you are a {@link FlowrAnalyzerProjectDiscoveryPlugin} and want to modify the available files, you can use the {@link FlowrAnalyzerFilesContext} directly.
+ */
+export interface ReadOnlyFlowrAnalyzerFilesContext {
+    /**
+     * The name of this context.
+     */
+    readonly name: string;
+    /**
+     * The loading order context provides access to the loading order of script files in the project.
+     */
+    readonly loadingOrder: ReadOnlyFlowrAnalyzerLoadingOrderContext;
+    /**
+     * Get all requests that have been added to this context.
+     *
+     * @example If you want to obtain all description files, use
+     * ```ts
+     * getFilesByRole(SpecialFileRole.Description)
+     * ```
+     */
+    getFilesByRole<Role extends SpecialFileRole>(role: Role): SpecialFiles[Role];
+}
+/**
+ * This is the analyzer file context to be modified by all plugins that affect the files.
+ * If you are interested in inspecting these files, refer to {@link ReadOnlyFlowrAnalyzerFilesContext}.
+ * Plugins, however, can use this context directly to modify files.
+ */
+export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerContext<RProjectAnalysisRequest, (RParseRequest | FlowrFile<string>)[], FlowrAnalyzerProjectDiscoveryPlugin> implements ReadOnlyFlowrAnalyzerFilesContext {
+    readonly name = "flowr-analyzer-files-context";
+    readonly loadingOrder: FlowrAnalyzerLoadingOrderContext;
+    private files;
+    private readonly fileLoaders;
+    private specialFiles;
+    constructor(loadingOrder: FlowrAnalyzerLoadingOrderContext, plugins: readonly FlowrAnalyzerProjectDiscoveryPlugin[], fileLoaders: readonly FlowrAnalyzerFilePlugin[]);
+    /**
+     * Add multiple requests to the context. This is just a convenience method that calls {@link addRequest} for each request.
+     */
+    addRequests(requests: readonly RAnalysisRequest[]): void;
+    /**
+     * Add a request to the context. If the request is of type `project`, it will be expanded using the registered {@link FlowrAnalyzerProjectDiscoveryPlugin}s.
+     */
+    addRequest(request: RAnalysisRequest): void;
+    /**
+     * Add multiple files to the context. This is just a convenience method that calls {@link addFile} for each file.
+     */
+    addFiles(...files: (string | FlowrFileProvider<string> | RParseRequestFromFile)[]): void;
+    /**
+     * Add a file to the context. If the file has a special role, it will be added to the corresponding list of special files.
+     * This method also applies any registered {@link FlowrAnalyzerFilePlugin}s to the file before adding it to the context.
+     */
+    addFile(file: string | FlowrFileProvider<string> | RParseRequestFromFile, role?: SpecialFileRole): void;
+    private fileLoadPlugins;
+    /**
+     * Get all requests that have been added to this context.
+     * This is a convenience method that calls {@link FlowrAnalyzerLoadingOrderContext.getLoadingOrder}.
+     */
+    computeLoadingOrder(): readonly RParseRequest[];
+    getFilesByRole<Role extends SpecialFileRole>(role: Role): SpecialFiles[Role];
+}