@eagleoutice/flowr 2.6.2 → 2.7.0

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

@@ -1,6 +1,11 @@
-import { type RAnalysisRequest, type ReadOnlyFlowrAnalyzerFilesContext, FlowrAnalyzerFilesContext } from './flowr-analyzer-files-context';
-import { type ReadOnlyFlowrAnalyzerDependenciesContext, FlowrAnalyzerDependenciesContext } from './flowr-analyzer-dependencies-context';
+import { FlowrAnalyzerFilesContext, type RAnalysisRequest, type ReadOnlyFlowrAnalyzerFilesContext } from './flowr-analyzer-files-context';
+import { FlowrAnalyzerDependenciesContext, type ReadOnlyFlowrAnalyzerDependenciesContext } from './flowr-analyzer-dependencies-context';
 import { type FlowrAnalyzerPlugin, PluginType } from '../plugins/flowr-analyzer-plugin';
+import type { fileProtocol, RParseRequestFromFile, RParseRequests } from '../../r-bridge/retriever';
+import type { FlowrConfigOptions } from '../../config';
+import type { FlowrFileProvider } from './flowr-file';
+import type { ReadOnlyFlowrAnalyzerEnvironmentContext } from './flowr-analyzer-environment-context';
+import { FlowrAnalyzerEnvironmentContext } from './flowr-analyzer-environment-context';
 /**
  * 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}).
@@ -15,6 +20,14 @@ export interface ReadOnlyFlowrAnalyzerContext {
      * The dependencies context provides access to the identified dependencies and their versions.
      */
     readonly deps: ReadOnlyFlowrAnalyzerDependenciesContext;
+    /**
+     * The environment context provides access to the environment information used during analysis.
+     */
+    readonly env: ReadOnlyFlowrAnalyzerEnvironmentContext;
+    /**
+     * The configuration options used by the analyzer.
+     */
+    readonly config: FlowrConfigOptions;
 }
 /**
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
@@ -31,11 +44,13 @@ export interface ReadOnlyFlowrAnalyzerContext {
 export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContext {
     readonly files: FlowrAnalyzerFilesContext;
     readonly deps: FlowrAnalyzerDependenciesContext;
-    constructor(plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
+    readonly env: FlowrAnalyzerEnvironmentContext;
+    readonly config: FlowrConfigOptions;
+    constructor(config: FlowrConfigOptions, plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
     /** delegate request addition */
     addRequests(requests: readonly RAnalysisRequest[]): void;
-    /** delegate request addition */
-    addRequest(request: RAnalysisRequest): void;
+    addFile(f: string | FlowrFileProvider | RParseRequestFromFile): void;
+    addFiles(f: (string | FlowrFileProvider | RParseRequestFromFile)[]): void;
     /** this conducts all the step that can be done before the main analysis run */
     resolvePreAnalysis(): void;
     /**
@@ -49,3 +64,20 @@ export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContex
      */
     reset(): void;
 }
+/**
+ * Lifting {@link requestFromInput} to create a full {@link FlowrAnalyzerContext} from input requests.
+ * Please use this only for a "quick" setup, or to have compatibility with the pre-project flowR era.
+ * Otherwise, refer to a {@link FlowrAnalyzerBuilder} to create a fully customized {@link FlowrAnalyzer} instance.
+ * @see {@link requestFromInput} - for details on how inputs are processed into requests.
+ * @see {@link contextFromSources} - to create a context from source code strings directly.
+ */
+export declare function contextFromInput(input: `${typeof fileProtocol}${string}` | string | readonly string[] | RParseRequests, config?: FlowrConfigOptions, plugins?: FlowrAnalyzerPlugin[]): FlowrAnalyzerContext;
+/**
+ * Create a {@link FlowrAnalyzerContext} from a set of source code strings.
+ * @param sources - A record mapping file paths to their source code content.
+ * @param config  - Configuration options for the analyzer.
+ * @param plugins - Optional plugins to extend the analyzer's functionality.
+ * @see {@link contextFromInput}    - to create a context from input requests.
+ * @see {@link FlowrInlineTextFile} - to create inline text files for the sources.
+ */
+export declare function contextFromSources(sources: Record<string, string>, config?: FlowrConfigOptions, plugins?: FlowrAnalyzerPlugin[]): FlowrAnalyzerContext;

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

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzerContext = void 0;
+exports.contextFromInput = contextFromInput;
+exports.contextFromSources = contextFromSources;
 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");
+const arrays_1 = require("../../util/collections/arrays");
+const retriever_1 = require("../../r-bridge/retriever");
+const config_1 = require("../../config");
+const flowr_file_1 = require("./flowr-file");
+const flowr_analyzer_environment_context_1 = require("./flowr-analyzer-environment-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})
@@ -20,18 +27,24 @@ const flowr_analyzer_loading_order_context_1 = require("./flowr-analyzer-loading
 class FlowrAnalyzerContext {
     files;
     deps;
-    constructor(plugins) {
+    env;
+    config;
+    constructor(config, plugins) {
+        this.config = config;
         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) ?? []));
+        this.env = new flowr_analyzer_environment_context_1.FlowrAnalyzerEnvironmentContext(this);
     }
     /** delegate request addition */
     addRequests(requests) {
         this.files.addRequests(requests);
     }
-    /** delegate request addition */
-    addRequest(request) {
-        this.files.addRequest(request);
+    addFile(f) {
+        this.files.addFile(f);
+    }
+    addFiles(f) {
+        this.files.addFiles(f);
     }
     /** this conducts all the step that can be done before the main analysis run */
     resolvePreAnalysis() {
@@ -55,4 +68,38 @@ class FlowrAnalyzerContext {
     }
 }
 exports.FlowrAnalyzerContext = FlowrAnalyzerContext;
+/**
+ * Lifting {@link requestFromInput} to create a full {@link FlowrAnalyzerContext} from input requests.
+ * Please use this only for a "quick" setup, or to have compatibility with the pre-project flowR era.
+ * Otherwise, refer to a {@link FlowrAnalyzerBuilder} to create a fully customized {@link FlowrAnalyzer} instance.
+ * @see {@link requestFromInput} - for details on how inputs are processed into requests.
+ * @see {@link contextFromSources} - to create a context from source code strings directly.
+ */
+function contextFromInput(input, config = config_1.defaultConfigOptions, plugins) {
+    const context = new FlowrAnalyzerContext(config, (0, arrays_1.arraysGroupBy)(plugins ?? [], (p) => p.type));
+    if (typeof input === 'string' || Array.isArray(input) && input.every(i => typeof i === 'string')) {
+        const requests = (0, retriever_1.requestFromInput)(input);
+        context.addRequests(Array.isArray(requests) ? requests : [requests]);
+    }
+    else {
+        const requests = Array.isArray(input) ? input : [input];
+        context.addRequests(requests);
+    }
+    return context;
+}
+/**
+ * Create a {@link FlowrAnalyzerContext} from a set of source code strings.
+ * @param sources - A record mapping file paths to their source code content.
+ * @param config  - Configuration options for the analyzer.
+ * @param plugins - Optional plugins to extend the analyzer's functionality.
+ * @see {@link contextFromInput}    - to create a context from input requests.
+ * @see {@link FlowrInlineTextFile} - to create inline text files for the sources.
+ */
+function contextFromSources(sources, config = config_1.defaultConfigOptions, plugins) {
+    const context = new FlowrAnalyzerContext(config, (0, arrays_1.arraysGroupBy)(plugins ?? [], (p) => p.type));
+    for (const [p, c] of Object.entries(sources)) {
+        context.addFile(new flowr_file_1.FlowrInlineTextFile(p, c));
+    }
+    return context;
+}
 //# sourceMappingURL=flowr-analyzer-context.js.map

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

@@ -0,0 +1,47 @@
+import type { FlowrAnalyzerContext } from './flowr-analyzer-context';
+import type { IEnvironment, REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { DeepReadonly } from 'ts-essentials';
+import type { Fingerprint } from '../../slicing/static/fingerprint';
+/**
+ * This is the read-only interface to the {@link FlowrAnalyzerEnvironmentContext},
+ * which provides access to the built-in environment used during analysis.
+ */
+export interface ReadOnlyFlowrAnalyzerEnvironmentContext {
+    /**
+     * Get the built-in environment used during analysis.
+     */
+    get builtInEnvironment(): DeepReadonly<IEnvironment>;
+    /**
+     * Get the empty built-in environment used during analysis.
+     * The empty built-in environment only contains primitive definitions.
+     */
+    get emptyBuiltInEnvironment(): DeepReadonly<IEnvironment>;
+    /**
+     * Create a new {@link REnvironmentInformation|environment} with the configured built-in environment as base.
+     */
+    makeCleanEnv(): REnvironmentInformation;
+    /**
+     * Get the fingerprint of the clean environment with the configured built-in environment as base.
+     */
+    getCleanEnvFingerprint(): Fingerprint;
+    /**
+     * Create a new {@link REnvironmentInformation|environment} with an empty built-in environment as base.
+     */
+    makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+}
+/**
+ * This context is responsible for providing the built-in environment.
+ * It creates the built-in environment based on the configuration provided in the {@link FlowrAnalyzerContext}.
+ */
+export declare class FlowrAnalyzerEnvironmentContext implements ReadOnlyFlowrAnalyzerEnvironmentContext {
+    readonly name = "flowr-analyzer-environment-context";
+    private readonly builtInEnv;
+    private readonly emptyBuiltInEnv;
+    private builtInEnvFingerprint;
+    constructor(ctx: FlowrAnalyzerContext);
+    get builtInEnvironment(): DeepReadonly<IEnvironment>;
+    get emptyBuiltInEnvironment(): DeepReadonly<IEnvironment>;
+    makeCleanEnv(): REnvironmentInformation;
+    getCleanEnvFingerprint(): Fingerprint;
+    makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerEnvironmentContext = void 0;
+const environment_1 = require("../../dataflow/environments/environment");
+const built_in_config_1 = require("../../dataflow/environments/built-in-config");
+const fingerprint_1 = require("../../slicing/static/fingerprint");
+/**
+ * This context is responsible for providing the built-in environment.
+ * It creates the built-in environment based on the configuration provided in the {@link FlowrAnalyzerContext}.
+ */
+class FlowrAnalyzerEnvironmentContext {
+    name = 'flowr-analyzer-environment-context';
+    builtInEnv;
+    emptyBuiltInEnv;
+    builtInEnvFingerprint;
+    constructor(ctx) {
+        const builtInsConfig = ctx.config.semantics.environment.overwriteBuiltIns;
+        const builtIns = (0, built_in_config_1.getBuiltInDefinitions)(builtInsConfig.definitions, builtInsConfig.loadDefaults);
+        this.builtInEnv = new environment_1.Environment(undefined, true);
+        this.builtInEnv.memory = builtIns.builtInMemory;
+        this.emptyBuiltInEnv = new environment_1.Environment(undefined, true);
+        this.emptyBuiltInEnv.memory = builtIns.emptyBuiltInMemory;
+    }
+    get builtInEnvironment() {
+        return this.builtInEnv;
+    }
+    get emptyBuiltInEnvironment() {
+        return this.emptyBuiltInEnv;
+    }
+    makeCleanEnv() {
+        return {
+            current: new environment_1.Environment(this.builtInEnv),
+            level: 0
+        };
+    }
+    getCleanEnvFingerprint() {
+        if (!this.builtInEnvFingerprint) {
+            this.builtInEnvFingerprint = (0, fingerprint_1.envFingerprint)(this.makeCleanEnv());
+        }
+        return this.builtInEnvFingerprint;
+    }
+    makeCleanEnvWithEmptyBuiltIns() {
+        return {
+            current: new environment_1.Environment(this.emptyBuiltInEnv),
+            level: 0
+        };
+    }
+}
+exports.FlowrAnalyzerEnvironmentContext = FlowrAnalyzerEnvironmentContext;
+//# sourceMappingURL=flowr-analyzer-environment-context.js.map

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

@@ -1,9 +1,9 @@
 import { AbstractFlowrAnalyzerContext } from './abstract-flowr-analyzer-context';
-import { type RParseRequest, type RParseRequestFromFile } from '../../r-bridge/retriever';
+import type { RParseRequestFromText, 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, type FlowrFileProvider, SpecialFileRole } from './flowr-file';
+import { FlowrFile, type FlowrFileProvider, FileRole } 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.
@@ -16,11 +16,12 @@ export interface RProjectAnalysisRequest {
     readonly content: string;
 }
 export type RAnalysisRequest = RParseRequest | RProjectAnalysisRequest;
-export type SpecialFiles = {
-    [SpecialFileRole.Description]: FlowrDescriptionFile[];
-    [SpecialFileRole.Namespace]: FlowrFileProvider[];
-    [SpecialFileRole.Data]: FlowrFileProvider[];
-    [SpecialFileRole.Other]: FlowrFileProvider[];
+export type RoleBasedFiles = {
+    [FileRole.Description]: FlowrDescriptionFile[];
+    [FileRole.Namespace]: FlowrFileProvider[];
+    [FileRole.Source]: FlowrFileProvider[];
+    [FileRole.Data]: FlowrFileProvider[];
+    [FileRole.Other]: FlowrFileProvider[];
 };
 /**
  * This is the read-only interface for the files context, which is used to manage all files known to the {@link FlowrAnalyzer}.
@@ -43,7 +44,37 @@ export interface ReadOnlyFlowrAnalyzerFilesContext {
      * getFilesByRole(SpecialFileRole.Description)
      * ```
      */
-    getFilesByRole<Role extends SpecialFileRole>(role: Role): SpecialFiles[Role];
+    getFilesByRole<Role extends FileRole>(role: Role): RoleBasedFiles[Role];
+    /**
+     * Check if the context has a file with the given path.
+     * Please note, that this may also check the file system, depending on the configuration
+     * (see {@link FlowrConfigOptions.project.resolveUnknownPathsOnDisk}).
+     * @param path - The path to the file.
+     *
+     * If you do not know the exact path or, e.g., casing of the file, use {@link exists} instead.
+     */
+    hasFile(path: string): boolean;
+    /**
+     * Check if a file exists at the given path, optionally ignoring case.
+     * @param path - The path to the file.
+     * @param ignoreCase - Whether to ignore case when checking for the file.
+     *
+     * Please note that this method checks the file system based on the configuration (see {@link FlowrConfigOptions.project.resolveUnknownPathsOnDisk}).
+     * @returns The actual path of the file if it exists, otherwise `undefined`.
+     */
+    exists(path: string, ignoreCase: boolean): string | undefined;
+    /**
+     * Until parsers support multiple request types from the virtual context system,
+     * we resolve their contents.
+     */
+    resolveRequest(r: RParseRequest): {
+        r: RParseRequestFromText;
+        path?: string;
+    };
+    /**
+     * Get all files that have been considered during dataflow analysis.
+     */
+    consideredFilesList(): readonly string[];
 }
 /**
  * This is the analyzer file context to be modified by all plugins that affect the files.
@@ -54,10 +85,21 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
     readonly name = "flowr-analyzer-files-context";
     readonly loadingOrder: FlowrAnalyzerLoadingOrderContext;
     private files;
+    private inlineFiles;
     private readonly fileLoaders;
-    private specialFiles;
+    /** these are all the paths of files that have been considered by the dataflow graph (even if not added) */
+    private readonly consideredFiles;
+    private byRole;
     constructor(loadingOrder: FlowrAnalyzerLoadingOrderContext, plugins: readonly FlowrAnalyzerProjectDiscoveryPlugin[], fileLoaders: readonly FlowrAnalyzerFilePlugin[]);
     reset(): void;
+    /**
+     * Record that a file has been considered during dataflow analysis.
+     */
+    addConsideredFile(path: string): void;
+    /**
+     * Get all files that have been considered during dataflow analysis.
+     */
+    consideredFilesList(): readonly string[];
     /**
      * Add multiple requests to the context. This is just a convenience method that calls {@link addRequest} for each request.
      */
@@ -65,21 +107,29 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
     /**
      * 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;
+    private addRequest;
     /**
      * 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;
+    addFiles(files: (string | FlowrFileProvider | 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;
+    addFile(file: string | FlowrFileProvider | RParseRequestFromFile, role?: FileRole): FlowrFileProvider<{
+        toString(): string;
+    }>;
+    hasFile(path: string): boolean;
+    exists(p: string, ignoreCase: boolean): string | undefined;
     private fileLoadPlugins;
+    resolveRequest(r: RParseRequest): {
+        r: RParseRequestFromText;
+        path?: string;
+    };
     /**
      * 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];
+    getFilesByRole<Role extends FileRole>(role: Role): RoleBasedFiles[Role];
 }

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzerFilesContext = void 0;
 const abstract_flowr_analyzer_context_1 = require("./abstract-flowr-analyzer-context");
@@ -8,23 +11,19 @@ const flowr_analyzer_project_discovery_plugin_1 = require("../plugins/project-di
 const flowr_analyzer_file_plugin_1 = require("../plugins/file-plugins/flowr-analyzer-file-plugin");
 const flowr_file_1 = require("./flowr-file");
 const log_1 = require("../../util/log");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const fileLog = log_1.log.getSubLogger({ name: 'flowr-analyzer-files-context' });
-function obtainFileAndPath(file, role) {
-    let f;
-    let p;
+function wrapFile(file, role) {
     if (typeof file === 'string') {
-        f = new flowr_file_1.FlowrTextFile(file, role);
-        p = file;
+        return new flowr_file_1.FlowrTextFile(file, role);
     }
     else if ('request' in file) {
-        f = file;
-        p = file.content;
+        return flowr_file_1.FlowrFile.fromRequest(file);
     }
     else {
-        f = file;
-        p = file.path().toString();
+        return file;
     }
-    return { f, p };
 }
 /**
  * This is the analyzer file context to be modified by all plugins that affect the files.
@@ -34,15 +33,19 @@ function obtainFileAndPath(file, role) {
 class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.AbstractFlowrAnalyzerContext {
     name = 'flowr-analyzer-files-context';
     loadingOrder;
-    /* all project files etc., this contains *all* files, loading orders etc. are to be handled by plugins */
+    /* all project files etc., this contains *all* (non-inline) files, loading orders etc. are to be handled by plugins */
     files = new Map();
+    inlineFiles = [];
     fileLoaders;
+    /** these are all the paths of files that have been considered by the dataflow graph (even if not added) */
+    consideredFiles = [];
     /* files that are part of the analysis, e.g. source files */
-    specialFiles = {
-        [flowr_file_1.SpecialFileRole.Description]: [],
-        [flowr_file_1.SpecialFileRole.Namespace]: [],
-        [flowr_file_1.SpecialFileRole.Data]: [],
-        [flowr_file_1.SpecialFileRole.Other]: []
+    byRole = {
+        [flowr_file_1.FileRole.Description]: [],
+        [flowr_file_1.FileRole.Namespace]: [],
+        [flowr_file_1.FileRole.Source]: [],
+        [flowr_file_1.FileRole.Data]: [],
+        [flowr_file_1.FileRole.Other]: []
     };
     constructor(loadingOrder, plugins, fileLoaders) {
         super(loadingOrder.getAttachedContext(), flowr_analyzer_project_discovery_plugin_1.FlowrAnalyzerProjectDiscoveryPlugin.defaultPlugin(), plugins);
@@ -53,6 +56,18 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
         this.loadingOrder.reset();
         this.files = new Map();
     }
+    /**
+     * Record that a file has been considered during dataflow analysis.
+     */
+    addConsideredFile(path) {
+        this.consideredFiles.push(path);
+    }
+    /**
+     * Get all files that have been considered during dataflow analysis.
+     */
+    consideredFilesList() {
+        return this.consideredFiles;
+    }
     /**
      * Add multiple requests to the context. This is just a convenience method that calls {@link addRequest} for each request.
      */
@@ -67,9 +82,6 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
     addRequest(request) {
         if (request.request !== 'project') {
             this.loadingOrder.addRequest(request);
-            if (request.request === 'file') {
-                this.files.set(request.content, request);
-            }
             return;
         }
         const expandedRequests = this.applyPlugins(request).flat();
@@ -85,7 +97,7 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
     /**
      * Add multiple files to the context. This is just a convenience method that calls {@link addFile} for each file.
      */
-    addFiles(...files) {
+    addFiles(files) {
         for (const file of files) {
             this.addFile(file);
         }
@@ -95,29 +107,88 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
      * This method also applies any registered {@link FlowrAnalyzerFilePlugin}s to the file before adding it to the context.
      */
     addFile(file, role) {
-        const { f, p } = obtainFileAndPath(file, role);
-        const { f: fA, p: pA } = this.fileLoadPlugins(f, p);
-        const exist = this.files.get(pA);
-        (0, assert_1.guard)(exist === undefined || exist === fA, `File ${pA} already added to the context.`);
-        this.files.set(pA, fA);
-        if (!(0, retriever_1.isParseRequest)(fA) && fA.role) {
-            this.specialFiles[fA.role].push(fA);
+        const f = this.fileLoadPlugins(wrapFile(file, role));
+        if (f.path() === flowr_file_1.FlowrFile.INLINE_PATH) {
+            this.inlineFiles.push(f);
+        }
+        else {
+            const exist = this.files.get(f.path());
+            (0, assert_1.guard)(exist === undefined || exist === f, `File ${f.path()} already added to the context.`);
+            this.files.set(f.path(), f);
+        }
+        if (f.role) {
+            this.byRole[f.role].push(f);
+        }
+        return f;
+    }
+    hasFile(path) {
+        return this.files.has(path)
+            || (this.ctx.config.project.resolveUnknownPathsOnDisk && fs_1.default.existsSync(path));
+    }
+    exists(p, ignoreCase) {
+        try {
+            if (!ignoreCase) {
+                return this.hasFile(p) ? p : undefined;
+            }
+            // walk the directory and find the first match
+            const dir = path_1.default.dirname(p);
+            const file = path_1.default.basename(p);
+            // try to find in local known files first
+            const localFound = Array.from(this.files.keys()).find(f => {
+                return path_1.default.dirname(f) === dir && path_1.default.basename(f).toLowerCase() === file.toLowerCase();
+            });
+            if (localFound) {
+                return localFound;
+            }
+            if (this.ctx.config.project.resolveUnknownPathsOnDisk) {
+                const files = fs_1.default.readdirSync(dir);
+                const found = files.find(f => f.toLowerCase() === file.toLowerCase());
+                return found ? path_1.default.join(dir, found) : undefined;
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
         }
     }
-    fileLoadPlugins(f, p) {
+    fileLoadPlugins(f) {
         let fFinal = f;
-        let pFinal = p;
-        if (!(0, retriever_1.isParseRequest)(f)) { // we have to change the types when we integrate the adapters
-            for (const loader of this.fileLoaders) {
-                if (loader.applies(p)) {
-                    fileLog.debug(`Applying file loader ${loader.name} to file ${p}`);
-                    fFinal = loader.processor(this.ctx, f);
-                    pFinal = f.path().toString();
-                    break;
-                }
+        for (const loader of this.fileLoaders) {
+            if (loader.applies(f.path())) {
+                fileLog.debug(`Applying file loader ${loader.name} to file ${f.path()}`);
+                fFinal = loader.processor(this.ctx, f);
+                break;
+            }
+        }
+        return fFinal;
+    }
+    resolveRequest(r) {
+        if (r.request === 'text') {
+            return { r };
+        }
+        const file = this.files.get(r.content);
+        if (file === undefined && this.ctx.config.project.resolveUnknownPathsOnDisk) {
+            fileLog.debug(`File ${r.content} not found in context, trying to load from disk.`);
+            if (fs_1.default.existsSync(r.content)) {
+                const loadedFile = this.addFile(new flowr_file_1.FlowrTextFile(r.content));
+                return {
+                    r: {
+                        request: 'text',
+                        content: loadedFile.content().toString(),
+                    },
+                    path: loadedFile.path()
+                };
             }
         }
-        return { f: fFinal, p: pFinal };
+        (0, assert_1.guard)(file !== undefined && file !== null, `File ${r.content} not found in context.`);
+        const content = file.content();
+        return {
+            r: {
+                request: 'text',
+                content: typeof content === 'string' ? content : '',
+            },
+            path: file.path()
+        };
     }
     /**
      * Get all requests that have been added to this context.
@@ -127,7 +198,7 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
         return this.loadingOrder.getLoadingOrder();
     }
     getFilesByRole(role) {
-        return this.specialFiles[role];
+        return this.byRole[role];
     }
 }
 exports.FlowrAnalyzerFilesContext = FlowrAnalyzerFilesContext;