@eagleoutice/flowr 2.6.1 → 2.6.3

package/project/flowr-analyzer-builder.js

@@ -2,26 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzerBuilder = void 0;
 const config_1 = require("../config");
-const retriever_1 = require("../r-bridge/retriever");
 const flowr_analyzer_1 = require("./flowr-analyzer");
 const engines_1 = require("../engines");
 const assert_1 = require("../util/assert");
-const files_1 = require("../util/files");
 const flowr_analyzer_context_1 = require("./context/flowr-analyzer-context");
 const flowr_analyzer_cache_1 = require("./cache/flowr-analyzer-cache");
+const flowr_analyzer_plugin_defaults_1 = require("./plugins/flowr-analyzer-plugin-defaults");
+const plugin_registry_1 = require("./plugins/plugin-registry");
 /**
  * Builder for the {@link FlowrAnalyzer}, use it to configure all analysis aspects before creating the analyzer instance
  * with {@link FlowrAnalyzerBuilder#build|`.build()`} or {@link FlowrAnalyzerBuilder#buildSync|`.buildSync()`}.
  *
- * You can add new files and folders to analyze using the constructor or the {@link FlowrAnalyzerBuilder#add|`.add()`} method.
- *
+ * You can add new files and folders to analyze using the {@link FlowrAnalyzer#addRequest|`.addRequest()`} method on the resulting analyzer.
  * @example Let's create an analyzer for a single R script file:
  *
  * ```ts
  * const analyzer = new FlowrAnalyzerBuilder()
- *                      .add('file:///path/to/script.R')
  *                      .setParser(new TreeSitterExecutor())
- *                      .buildSync();
+ *                      .buildSync()
+ *                      .addRequest('file:///path/to/script.R')
+ *
  * ```
  *
  * If you now want to get the dataflow information for the file, you can do this:
@@ -30,63 +30,25 @@ const flowr_analyzer_cache_1 = require("./cache/flowr-analyzer-cache");
  * const dfInfo = await analyzer.dataflow();
  * console.log(dfInfo);
  * ```
+ * @see https://github.com/flowr-analysis/flowr/wiki/Analyzer
  */
 class FlowrAnalyzerBuilder {
     flowrConfig = (0, config_1.cloneConfig)(config_1.defaultConfigOptions);
     parser;
-    request;
     input;
     plugins = new Map();
     /**
-     * Create a new builder instance.
-     * @param request - The code to analyze
-     */
-    constructor(request) {
-        this.addRequest(request ?? []);
-    }
-    /**
-     * Add one or multiple requests to analyze.
-     * This is a convenience method that uses {@link addRequest} and {@link addRequestFromInput} internally.
-     * @param request - One or multiple requests or a file path (with the `file://` protocol). If you just enter a string, it will be interpreted as R code.
-     */
-    add(request) {
-        if (Array.isArray(request) || (0, retriever_1.isParseRequest)(request)) {
-            this.addRequest(request);
-        }
-        else if (typeof request === 'string') {
-            const trimmed = request.substring(retriever_1.fileProtocol.length);
-            if (request.startsWith(retriever_1.fileProtocol) && !(0, files_1.isFilePath)(trimmed)) {
-                this.addRequest({ request: 'project', content: trimmed });
-            }
-            else {
-                this.addRequestFromInput(request);
-            }
-        }
-        else {
-            this.addRequest(request);
-        }
-        return this;
-    }
-    /**
-     * Add one or multiple requests to analyze the builder.
+     * Creates a new builder for the {@link FlowrAnalyzer}.
+     * By default, the standard set of plugins as returned by {@link FlowrAnalyzerPluginDefaults} are registered.
+     * @param withDefaultPlugins - Whether to register the default plugins upon creation. Default is `true`.
+     * @see {@link FlowrAnalyzerPluginDefaults} - for the default plugin set.
+     * @see {@link FlowrAnalyzerBuilder#registerPlugins} - to add more plugins.
+     * @see {@link FlowrAnalyzerBuilder#unregisterPlugins} - to remove plugins.
      */
-    addRequest(request) {
-        const r = Array.isArray(request) ? request : [request];
-        if (this.request) {
-            this.request = this.request.concat(request);
-        }
-        else {
-            this.request = r;
+    constructor(withDefaultPlugins = true) {
+        if (withDefaultPlugins) {
+            this.registerPlugins(...(0, flowr_analyzer_plugin_defaults_1.FlowrAnalyzerPluginDefaults)());
         }
-        return this;
-    }
-    /**
-     * Add a request created from the given input.
-     * This is a convenience method that uses {@link requestFromInput} internally.
-     */
-    addRequestFromInput(input) {
-        this.addRequest((0, retriever_1.requestFromInput)(input));
-        return this;
     }
     /**
      * Apply an amendment to the configuration the builder currently holds.
@@ -133,29 +95,29 @@ class FlowrAnalyzerBuilder {
     }
     /**
      * Register one or multiple additional plugins.
-     *
+     * For the default plugin set, please refer to {@link FlowrAnalyzerPluginDefaults}, they can be registered
+     * by passing `true` to the {@link FlowrAnalyzerBuilder} constructor.
+     * @param plugin - One or multiple plugins to register.
      * @see {@link FlowrAnalyzerBuilder#unregisterPlugins} to remove plugins.
      */
     registerPlugins(...plugin) {
         for (const p of plugin) {
-            const g = this.plugins.get(p.type);
-            if (g === undefined) {
-                this.plugins.set(p.type, [p]);
-            }
-            else {
-                g.push(p);
-            }
+            const s = (0, plugin_registry_1.makePlugin)(p);
+            const g = this.plugins.get(s.type) ?? [];
+            g.push(s);
+            this.plugins.set(s.type, g);
         }
         return this;
     }
     /**
      * Remove one or multiple plugins.
+     * @see {@link FlowrAnalyzerBuilder#registerPlugins} to add plugins.
      */
     unregisterPlugins(...plugin) {
         for (const p of plugin) {
-            const g = this.plugins.get(p.type);
-            if (g !== undefined) {
-                this.plugins.set(p.type, g.filter(x => x !== p));
+            const name = typeof p === 'string' ? p : p.name;
+            for (const [type, plugins] of this.plugins) {
+                this.plugins.set(type, plugins.filter((pl) => pl.name !== name));
             }
         }
         return this;
@@ -164,7 +126,8 @@ class FlowrAnalyzerBuilder {
      * Create the {@link FlowrAnalyzer} instance using the given information.
      * Please note that the only reason this is `async` is that if no parser is set,
      * we need to retrieve the default engine instance which is an async operation.
-     * If you set the parser using {@link FlowrAnalyzerBuilder#setParser},
+     * If you have already initialized the engine (e.g., with {@link TreeSitterExecutor#initTreeSitter}),
+     * you can use the synchronous version {@link FlowrAnalyzerBuilder#buildSync} instead.
      */
     async build() {
         if (!this.parser) {
@@ -179,18 +142,16 @@ class FlowrAnalyzerBuilder {
      */
     buildSync() {
         (0, assert_1.guard)(this.parser !== undefined, 'No parser set, please use the setParser or setEngine method to set a parser before building the analyzer');
-        (0, assert_1.guard)(this.request !== undefined, 'Currently we require at least one request to build an analyzer, please provide one using the constructor or the addRequest method');
-        const context = new flowr_analyzer_context_1.FlowrAnalyzerContext(this.plugins);
-        context.addRequests(this.request);
-        // we do it here to save time later if the analyzer is to be duplicated
-        context.resolvePreAnalysis();
+        const context = new flowr_analyzer_context_1.FlowrAnalyzerContext(this.flowrConfig, this.plugins);
         const cache = flowr_analyzer_cache_1.FlowrAnalyzerCache.create({
             parser: this.parser,
-            config: this.flowrConfig,
-            request: context.files.computeLoadingOrder(),
+            context,
             ...(this.input ?? {})
         });
-        return new flowr_analyzer_1.FlowrAnalyzer(this.flowrConfig, this.parser, context, cache);
+        const analyzer = new flowr_analyzer_1.FlowrAnalyzer(this.parser, context, cache);
+        // we do it here to save time later if the analyzer is to be duplicated
+        context.resolvePreAnalysis();
+        return analyzer;
     }
 }
 exports.FlowrAnalyzerBuilder = FlowrAnalyzerBuilder;

package/project/flowr-analyzer.d.ts

@@ -1,6 +1,6 @@
 import type { FlowrConfigOptions } from '../config';
-import type { KnownParser, ParseStepOutput, RShellInformation, TreeSitterInformation } from '../r-bridge/parser';
-import type { Queries, QueryResults, SupportedQueryTypes } from '../queries/query';
+import type { KnownParser, KnownParserInformation } from '../r-bridge/parser';
+import { type Queries, type QueryResults, type SupportedQueryTypes } from '../queries/query';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
@@ -8,31 +8,51 @@ import type { CfgSimplificationPassName } from '../control-flow/cfg-simplificati
 import type { PipelinePerStepMetaInformation } from '../core/steps/pipeline/pipeline';
 import type { AnalyzerCacheType, FlowrAnalyzerCache } from './cache/flowr-analyzer-cache';
 import type { FlowrSearchLike, SearchOutput } from '../search/flowr-search-builder';
-import type { GetSearchElements } from '../search/flowr-search-executor';
+import { type GetSearchElements } from '../search/flowr-search-executor';
 import type { FlowrAnalyzerContext, ReadOnlyFlowrAnalyzerContext } from './context/flowr-analyzer-context';
 import { CfgKind } from './cfg-kind';
-import type { OutputCollectorConfiguration } from '../r-bridge/shell';
+import type { RAnalysisRequest } from './context/flowr-analyzer-files-context';
+import type { RParseRequestFromFile } from '../r-bridge/retriever';
+import { fileProtocol } from '../r-bridge/retriever';
+import type { FlowrFileProvider } from './context/flowr-file';
 /**
- * Exposes the central analyses and information provided by the {@link FlowrAnalyzer} to the linter, search, and query APIs.
- * This allows us to exchange the underlying implementation of the analyzer without affecting the APIs.
+ * Extends the {@link ReadonlyFlowrAnalysisProvider} with methods that allow modifying the analyzer state.
  */
-export interface FlowrAnalysisProvider {
-    /**
-     * Get the name of the parser used by the analyzer.
-     */
-    parserInformation(): Promise<TreeSitterInformation | RShellInformation>;
-    /**
-     * Sends a command to the underlying R engine and collects the output.
-     * @param command     - The command to send to the R engine.
-     * @param addonConfig - Additional configuration for the output collector.
-     */
-    sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
+export interface FlowrAnalysisProvider<Parser extends KnownParser = KnownParser> extends ReadonlyFlowrAnalysisProvider<Parser> {
     /**
      * Returns project context information.
      * If you are a user that wants to inspect the context, prefer {@link inspectContext} instead.
      * Please be aware that modifications to the context may break analyzer assumptions.
      */
     context(): FlowrAnalyzerContext;
+    /**
+     * Add one or multiple requests to analyze.
+     * @param request - One or multiple requests or a file path (with the `file://` protocol). If you just enter a string without the {@link fileProtocol}, it will be interpreted as R code.
+     * @see {@link FlowrAnalysisProvider.addFile|addFile} - for adding files to the analyzer's context.
+     */
+    addRequest(...request: (RAnalysisRequest | `${typeof fileProtocol}${string}` | string)[]): void;
+    /**
+     * Add one or multiple files to the analyzer's context.
+     * @param f - One or multiple file paths, file providers, or parse requests from file.
+     * @see {@link FlowrFileProvider} - for creating custom file providers.
+     * @see {@link FlowrAnalysisProvider.addRequest|addRequest} - for adding analysis requests to the analyzer.
+     */
+    addFile(...f: (string | FlowrFileProvider<string> | RParseRequestFromFile)[]): void;
+    /**
+     * Reset the analyzer state, including the context and the cache.
+     */
+    reset(): void;
+}
+/**
+ * Exposes the central analyses and information provided by the {@link FlowrAnalyzer} to the linter, search, and query APIs.
+ * This allows us to exchange the underlying implementation of the analyzer without affecting the APIs.
+ */
+export interface ReadonlyFlowrAnalysisProvider<Parser extends KnownParser = KnownParser> {
+    /**
+     * Returns a set of additional data and helper functions exposed by the underlying {@link KnownParser},
+     * including the parser's {@link BaseParserInformation.name} and corresponding version information.
+     */
+    parserInformation(): KnownParserInformation;
     /**
      * Returns a read-only version of the project context information.
      * This is the preferred method for users that want to inspect the context.
@@ -43,25 +63,45 @@ export interface FlowrAnalysisProvider {
      *
      * The parse result type depends on the {@link KnownParser} used by the analyzer.
      * @param force - Do not use the cache, instead force a new parse.
+     * @see {@link ReadonlyFlowrAnalysisProvider#peekParse} - to get the parse output if already available without triggering a new computation.
      */
-    parse(force?: boolean): Promise<ParseStepOutput<Awaited<ReturnType<KnownParser['parse']>>> & PipelinePerStepMetaInformation>;
+    parse(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['parse']>>;
+    /**
+     * Peek at the parse output for the request, if it was already computed.
+     */
+    peekParse(): NonNullable<AnalyzerCacheType<Parser>['parse']> | undefined;
     /**
      * Get the normalized abstract syntax tree for the request.
      * @param force - Do not use the cache, instead force new analyses.
+     * @see {@link ReadonlyFlowrAnalysisProvider#peekNormalize} - to get the normalized AST if already available without triggering a new computation.
      */
     normalize(force?: boolean): Promise<NormalizedAst & PipelinePerStepMetaInformation>;
+    /**
+     * Peek at the normalized abstract syntax tree for the request, if it was already computed.
+     */
+    peekNormalize(): NormalizedAst & PipelinePerStepMetaInformation | undefined;
     /**
      * Get the dataflow graph for the request.
      * @param force - Do not use the cache, instead force new analyses.
+     * @see {@link ReadonlyFlowrAnalysisProvider#peekDataflow} - to get the dataflow graph if already available without triggering a new computation.
      */
     dataflow(force?: boolean): Promise<DataflowInformation & PipelinePerStepMetaInformation>;
+    /**
+     * Peek at the dataflow graph for the request, if it was already computed.
+     */
+    peekDataflow(): DataflowInformation & PipelinePerStepMetaInformation | undefined;
     /**
      * Get the control flow graph (CFG) for the request.
      * @param simplifications - Simplification passes to be applied to the CFG.
      * @param kind            - The kind of CFG that is requested. By default, the CFG without dataflow information is returned.
      * @param force           - Do not use the cache, instead force new analyses.
+     * @see {@link ReadonlyFlowrAnalysisProvider#peekControlflow} - to get the CFG if already available without triggering a new computation.
      */
     controlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind, force?: boolean): Promise<ControlFlowInformation>;
+    /**
+     * Peek at the control flow graph (CFG) for the request, if it was already computed.
+     */
+    peekControlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind): ControlFlowInformation | undefined;
     /**
      * Access the query API for the request.
      * @param query - The list of queries.
@@ -75,10 +115,6 @@ export interface FlowrAnalysisProvider {
      * This executes all steps of the core analysis (parse, normalize, dataflow).
      */
     runFull(force?: boolean): Promise<void>;
-    /**
-     * Reset all caches used by the analyzer and effectively force all analyses to be redone.
-     */
-    reset(): void;
     /** This is the config used for the analyzer */
     flowrConfig: FlowrConfigOptions;
 }
@@ -89,34 +125,48 @@ export interface FlowrAnalysisProvider {
  * If you want the original pattern of creating a pipeline and running all steps, you can still do this with {@link FlowrAnalyzer#runFull}.
  *
  * To inspect the context of the analyzer, use {@link FlowrAnalyzer#inspectContext} (if you are a plugin and need to modify it, use {@link FlowrAnalyzer#context} instead).
+ * @see https://github.com/flowr-analysis/flowr/wiki/Analyzer
  */
-export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> implements FlowrAnalysisProvider {
-    readonly flowrConfig: FlowrConfigOptions;
+export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> implements ReadonlyFlowrAnalysisProvider<Parser> {
     /** The parser and engine backend */
     private readonly parser;
     /** The cache used for storing analysis results */
     private readonly cache;
     private readonly ctx;
+    private parserInfo;
     /**
      * Create a new analyzer instance.
      * **Prefer the use of the {@link FlowrAnalyzerBuilder} instead of calling this constructor directly.**
-     *
-     * @param config - The FlowR config to use for the analyses
      * @param parser - The parser to use for parsing the given request.
      * @param ctx    - The context to use for the analyses.
      * @param cache  - The caching layer to use for storing analysis results.
      */
-    constructor(config: FlowrConfigOptions, parser: Parser, ctx: FlowrAnalyzerContext, cache: FlowrAnalyzerCache<Parser>);
+    constructor(parser: Parser, ctx: FlowrAnalyzerContext, cache: FlowrAnalyzerCache<Parser>);
+    get flowrConfig(): FlowrConfigOptions;
     context(): FlowrAnalyzerContext;
-    parserInformation(): Promise<TreeSitterInformation | RShellInformation>;
-    sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
+    parserInformation(): KnownParserInformation;
     inspectContext(): ReadOnlyFlowrAnalyzerContext;
     reset(): void;
+    addRequest(...request: (RAnalysisRequest | readonly RAnalysisRequest[] | `${typeof fileProtocol}${string}` | string)[]): this;
+    addFile(...f: (string | FlowrFileProvider | RParseRequestFromFile)[]): this;
+    /**
+     * Add a request created from the given input.
+     * This is a convenience method that uses {@link requestFromInput} internally.
+     */
+    private addRequestFromInput;
+    /**
+     * Add one or multiple requests to analyze the builder.
+     */
+    private addAnalysisRequest;
     parse(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['parse']>>;
+    peekParse(): NonNullable<AnalyzerCacheType<Parser>['parse']> | undefined;
     normalize(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['normalize']>>;
+    peekNormalize(): NonNullable<AnalyzerCacheType<Parser>['normalize']> | undefined;
     dataflow(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['dataflow']>>;
+    peekDataflow(): NonNullable<AnalyzerCacheType<Parser>['dataflow']> | undefined;
     runFull(force?: boolean): Promise<void>;
     controlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind, force?: boolean): Promise<ControlFlowInformation>;
+    peekControlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind): ControlFlowInformation | undefined;
     query<Types extends SupportedQueryTypes = SupportedQueryTypes>(query: Queries<Types>): Promise<QueryResults<Types>>;
     runSearch<Search extends FlowrSearchLike>(search: Search): Promise<GetSearchElements<SearchOutput<Search>>>;
     /**

package/project/flowr-analyzer.js

@@ -4,8 +4,8 @@ exports.FlowrAnalyzer = void 0;
 const query_1 = require("../queries/query");
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
 const cfg_kind_1 = require("./cfg-kind");
-const shell_1 = require("../r-bridge/shell");
-const assert_1 = require("../util/assert");
+const retriever_1 = require("../r-bridge/retriever");
+const files_1 = require("../util/files");
 /**
  * Central class for conducting analyses with FlowR.
  * Use the {@link FlowrAnalyzerBuilder} to create a new instance.
@@ -13,40 +13,36 @@ const assert_1 = require("../util/assert");
  * If you want the original pattern of creating a pipeline and running all steps, you can still do this with {@link FlowrAnalyzer#runFull}.
  *
  * To inspect the context of the analyzer, use {@link FlowrAnalyzer#inspectContext} (if you are a plugin and need to modify it, use {@link FlowrAnalyzer#context} instead).
+ * @see https://github.com/flowr-analysis/flowr/wiki/Analyzer
  */
 class FlowrAnalyzer {
-    flowrConfig;
     /** The parser and engine backend */
     parser;
     /** The cache used for storing analysis results */
     cache;
     ctx;
+    parserInfo;
     /**
      * Create a new analyzer instance.
      * **Prefer the use of the {@link FlowrAnalyzerBuilder} instead of calling this constructor directly.**
-     *
-     * @param config - The FlowR config to use for the analyses
      * @param parser - The parser to use for parsing the given request.
      * @param ctx    - The context to use for the analyses.
      * @param cache  - The caching layer to use for storing analysis results.
      */
-    constructor(config, parser, ctx, cache) {
-        this.flowrConfig = config;
+    constructor(parser, ctx, cache) {
         this.parser = parser;
         this.ctx = ctx;
         this.cache = cache;
     }
+    get flowrConfig() {
+        return this.ctx.config;
+    }
     context() {
         return this.ctx;
     }
-    async parserInformation() {
-        return this.parser.name === 'r-shell' ?
-            { name: 'r-shell', rVersion: await this.parser.rVersion() }
-            : { name: 'tree-sitter' };
-    }
-    async sendCommandWithOutput(command, addonConfig) {
-        (0, assert_1.guard)(this.parser instanceof shell_1.RShell, 'sendCommandWithOutput can only be used with RShell parsers!');
-        return this.parser.sendCommandWithOutput(command, addonConfig);
+    parserInformation() {
+        this.parserInfo ??= this.parser.information(this);
+        return this.parserInfo;
     }
     inspectContext() {
         return this.ctx.inspect();
@@ -55,15 +51,60 @@ class FlowrAnalyzer {
         this.ctx.reset();
         this.cache.reset();
     }
+    addRequest(...request) {
+        for (const r of request) {
+            if (typeof r === 'string') {
+                const trimmed = r.substring(retriever_1.fileProtocol.length);
+                if (r.startsWith(retriever_1.fileProtocol) && !(0, files_1.isFilePath)(trimmed)) {
+                    this.addAnalysisRequest({ request: 'project', content: trimmed });
+                }
+                else {
+                    this.addRequestFromInput(r);
+                }
+            }
+            else {
+                this.addAnalysisRequest(r);
+            }
+        }
+        return this;
+    }
+    addFile(...f) {
+        this.ctx.addFiles(f);
+        return this;
+    }
+    /**
+     * Add a request created from the given input.
+     * This is a convenience method that uses {@link requestFromInput} internally.
+     */
+    addRequestFromInput(input) {
+        this.addAnalysisRequest((0, retriever_1.requestFromInput)(input));
+        return this;
+    }
+    /**
+     * Add one or multiple requests to analyze the builder.
+     */
+    addAnalysisRequest(request) {
+        this.ctx.addRequests((Array.isArray(request) ? request : [request]));
+        return this;
+    }
     async parse(force) {
         return this.cache.parse(force);
     }
+    peekParse() {
+        return this.cache.peekParse();
+    }
     async normalize(force) {
         return this.cache.normalize(force);
     }
+    peekNormalize() {
+        return this.cache.peekNormalize();
+    }
     async dataflow(force) {
         return this.cache.dataflow(force);
     }
+    peekDataflow() {
+        return this.cache.peekDataflow();
+    }
     async runFull(force) {
         await this.dataflow(force);
         return;
@@ -71,6 +112,9 @@ class FlowrAnalyzer {
     async controlflow(simplifications, kind, force) {
         return this.cache.controlflow(force, kind ?? cfg_kind_1.CfgKind.NoDataflow, simplifications);
     }
+    peekControlflow(simplifications, kind) {
+        return this.cache.peekControlflow(kind ?? cfg_kind_1.CfgKind.NoDataflow, simplifications);
+    }
     async query(query) {
         return (0, query_1.executeQueries)({ analyzer: this }, query);
     }

package/project/plugins/file-plugins/flowr-analyzer-description-file-plugin.d.ts

@@ -3,7 +3,7 @@ import { SemVer } from 'semver';
 import type { PathLike } from 'fs';
 import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
 import { FlowrDescriptionFile } from './flowr-description-file';
-import type { FlowrFileProvider } from '../../context/flowr-file';
+import { type FlowrFileProvider } from '../../context/flowr-file';
 export declare const descriptionFileLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This plugin provides support for R `DESCRIPTION` files.
@@ -12,6 +12,12 @@ export declare class FlowrAnalyzerDescriptionFilePlugin extends FlowrAnalyzerFil
     readonly name = "flowr-analyzer-description-file-plugin";
     readonly description = "This plugin provides support for DESCRIPTION files and extracts their content into key-value(s) pairs.";
     readonly version: SemVer;
+    private readonly pattern;
+    /**
+     * Creates a new instance of the DESCRIPTION file plugin.
+     * @param filePattern - The pattern to identify DESCRIPTION files, see {@link DescriptionFilePattern} for the default pattern.
+     */
+    constructor(filePattern?: RegExp);
     applies(file: PathLike): boolean;
-    process(_ctx: FlowrAnalyzerContext, file: FlowrFileProvider<string>): FlowrDescriptionFile;
+    process(_ctx: FlowrAnalyzerContext, file: FlowrFileProvider): FlowrDescriptionFile;
 }

package/project/plugins/file-plugins/flowr-analyzer-description-file-plugin.js

@@ -6,7 +6,9 @@ const semver_1 = require("semver");
 const log_1 = require("../../../util/log");
 const flowr_description_file_1 = require("./flowr-description-file");
 const flowr_file_1 = require("../../context/flowr-file");
+const built_in_source_1 = require("../../../dataflow/internal/process/functions/call/built-in/built-in-source");
 exports.descriptionFileLog = log_1.log.getSubLogger({ name: 'flowr-analyzer-loading-order-description-file-plugin' });
+const DescriptionFilePattern = /^(DESCRIPTION|DESCRIPTION\.txt)$/i;
 /**
  * This plugin provides support for R `DESCRIPTION` files.
  */
@@ -14,14 +16,20 @@ class FlowrAnalyzerDescriptionFilePlugin extends flowr_analyzer_file_plugin_1.Fl
     name = 'flowr-analyzer-description-file-plugin';
     description = 'This plugin provides support for DESCRIPTION files and extracts their content into key-value(s) pairs.';
     version = new semver_1.SemVer('0.1.0');
+    pattern;
+    /**
+     * Creates a new instance of the DESCRIPTION file plugin.
+     * @param filePattern - The pattern to identify DESCRIPTION files, see {@link DescriptionFilePattern} for the default pattern.
+     */
+    constructor(filePattern = DescriptionFilePattern) {
+        super();
+        this.pattern = filePattern;
+    }
     applies(file) {
-        return /^(DESCRIPTION|DESCRIPTION\.txt)$/i.test(file.toString().split(/[/\\]/).pop() ?? '');
+        return this.pattern.test((0, built_in_source_1.platformBasename)(file.toString()));
     }
     process(_ctx, file) {
-        const f = flowr_description_file_1.FlowrDescriptionFile.from(file, flowr_file_1.SpecialFileRole.Description);
-        // already load it here
-        f.content();
-        return f;
+        return flowr_description_file_1.FlowrDescriptionFile.from(file, flowr_file_1.FileRole.Description);
     }
 }
 exports.FlowrAnalyzerDescriptionFilePlugin = FlowrAnalyzerDescriptionFilePlugin;

package/project/plugins/file-plugins/flowr-analyzer-file-plugin.d.ts

@@ -4,14 +4,14 @@ import type { FlowrFileProvider } from '../../context/flowr-file';
 /**
  * This is the base class for all plugins that load and possibly transform files when they are loaded.
  * Different from other plugins, these plugins trigger for each file that is loaded (if they {@link applies} to the file).
- * See the {@link FlowrAnalyzerFilesContext.addFile} for more information on how files are loaded and managed.
+ * See the {@link FlowrAnalyzer.addFile} for more information on how files are loaded and managed.
  *
- * It is upt to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
+ * It is up to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
  * of these plugins will determine which plugin gets to process the file.
  *
  * See {@link DefaultFlowrAnalyzerFilePlugin} for the no-op default implementation.
  */
-export declare abstract class FlowrAnalyzerFilePlugin extends FlowrAnalyzerPlugin<FlowrFileProvider<string>, FlowrFileProvider> {
+export declare abstract class FlowrAnalyzerFilePlugin extends FlowrAnalyzerPlugin<FlowrFileProvider, FlowrFileProvider> {
     readonly type = PluginType.FileLoad;
     /**
      * Determine whether this plugin applies to the given file.

package/project/plugins/file-plugins/flowr-analyzer-file-plugin.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzerFilePlugin = void 0;
 const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const flowr_file_1 = require("../../context/flowr-file");
 const semver_1 = require("semver");
 /**
  * This is the base class for all plugins that load and possibly transform files when they are loaded.
  * Different from other plugins, these plugins trigger for each file that is loaded (if they {@link applies} to the file).
- * See the {@link FlowrAnalyzerFilesContext.addFile} for more information on how files are loaded and managed.
+ * See the {@link FlowrAnalyzer.addFile} for more information on how files are loaded and managed.
  *
- * It is upt to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
+ * It is up to the construction to ensure that no two file plugins {@link applies} to the same file, otherwise, the loading order
  * of these plugins will determine which plugin gets to process the file.
  *
  * See {@link DefaultFlowrAnalyzerFilePlugin} for the no-op default implementation.
@@ -22,13 +23,18 @@ class FlowrAnalyzerFilePlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugi
 exports.FlowrAnalyzerFilePlugin = FlowrAnalyzerFilePlugin;
 class DefaultFlowrAnalyzerFilePlugin extends FlowrAnalyzerFilePlugin {
     name = 'default-file-plugin';
-    description = 'This is the default file plugin that does nothing.';
+    description = 'This is the default file plugin that does nothing (but assigning default .r/.R files).';
     version = new semver_1.SemVer('0.0.0');
     applies() {
         return true;
     }
-    process(_context, args) {
-        return args;
+    process(_ctx, arg) {
+        const path = arg.path().toString();
+        if (/\.r$/i.test(path)) {
+            // we just assign the role :D
+            arg.assignRole(flowr_file_1.FileRole.Source);
+        }
+        return arg;
     }
 }
 //# sourceMappingURL=flowr-analyzer-file-plugin.js.map

package/project/plugins/file-plugins/flowr-description-file.d.ts

@@ -1,5 +1,4 @@
-import type { FlowrFileProvider, SpecialFileRole } from '../../context/flowr-file';
-import { FlowrFile } from '../../context/flowr-file';
+import { type FlowrFileProvider, type FileRole, FlowrFile } from '../../context/flowr-file';
 export type DCF = Map<string, string[]>;
 /**
  * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
@@ -10,15 +9,14 @@ export declare class FlowrDescriptionFile extends FlowrFile<DCF> {
      * Prefer the static {@link FlowrDescriptionFile.from} method to create instances of this class as it will not re-create if already a description file
      * and handle role assignments.
      */
-    constructor(file: FlowrFileProvider<string>);
+    constructor(file: FlowrFileProvider);
     /**
      * Loads and parses the content of the wrapped file as a DCF structure.
-     *
      * @see {@link parseDCF} for details on the parsing logic.
      */
     protected loadContent(): DCF;
     /**
      * Description file lifter, this does not re-create if already a description file
      */
-    static from(file: FlowrFileProvider<string> | FlowrDescriptionFile, role?: SpecialFileRole): FlowrDescriptionFile;
+    static from(file: FlowrFileProvider | FlowrDescriptionFile, role?: FileRole): FlowrDescriptionFile;
 }

package/project/plugins/file-plugins/flowr-description-file.js

@@ -18,7 +18,6 @@ class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
     }
     /**
      * Loads and parses the content of the wrapped file as a DCF structure.
-     *
      * @see {@link parseDCF} for details on the parsing logic.
      */
     loadContent() {