@eagleoutice/flowr 2.6.3 → 2.7.2

package/linter/rules/absolute-path.js

@@ -49,15 +49,15 @@ function buildQuickFix(str, filePath, wd) {
 }
 /** return all strings constructable by these functions */
 const PathFunctions = {
-    'file.path': (df, vtx, config) => {
-        const fsep = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, undefined, 'fsep', true);
+    'file.path': (df, vtx, ctx) => {
+        const fsep = (0, resolve_argument_1.getArgumentStringValue)(ctx.config.solver.variables, df, vtx, undefined, 'fsep', true, ctx);
         // in the future we can access `.Platform$file.sep` here
         const sepValues = fsep?.values()?.flatMap(s => s.values().filter(assert_1.isNotUndefined)).toArray() ?? [path_1.default.sep];
         if (sepValues.some(s => s === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(s))) {
             // if we have no fsep, we cannot construct a path
             return undefined;
         }
-        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, 'unnamed', undefined, true);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(ctx.config.solver.variables, df, vtx, 'unnamed', undefined, true, ctx);
         const argValues = args ? Array.from(args.values()).flatMap(v => [...v]) : [];
         if (!argValues || argValues.length === 0 || argValues.some(v => v === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(v))) {
             // if we have no arguments, we cannot construct a path
@@ -139,7 +139,7 @@ exports.ABSOLUTE_PATH = {
                     const dfNode = data.dataflow.graph.getVertex(node.info.id);
                     if ((0, vertex_1.isFunctionCallVertex)(dfNode)) {
                         const handler = PathFunctions[dfNode.name ?? ''];
-                        const strings = handler ? handler(data.dataflow.graph, dfNode, data.analyzer.flowrConfig) : [];
+                        const strings = handler ? handler(data.dataflow.graph, dfNode, data.analyzer.inspectContext()) : [];
                         if (strings) {
                             return strings.filter(s => (0, strings_1.isAbsolutePath)(s, regex)).map(str => ({
                                 certainty: linter_format_1.LintingResultCertainty.Uncertain,

package/linter/rules/dataframe-access-validation.d.ts

@@ -2,7 +2,7 @@ import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/proces
 import type { FlowrSearchElements } from '../../search/flowr-search';
 import { type MergeableRecord } from '../../util/objects';
 import { type SourceRange } from '../../util/range';
-import { type LintingResult, LintingRuleCertainty } from '../linter-format';
+import { LintingRuleCertainty, type LintingResult } from '../linter-format';
 import { LintingRuleTag } from '../linter-tags';
 export interface DataFrameAccessValidationResult extends LintingResult {
     /** The type of the data frame access ("column" or "row") */
@@ -47,7 +47,7 @@ export declare const DATA_FRAME_ACCESS_VALIDATION: {
         readonly name: "Dataframe Access Validation";
         readonly tags: readonly [LintingRuleTag.Bug, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
         readonly certainty: LintingRuleCertainty.BestEffort;
-        readonly description: "Validates the existance of accessed columns and rows of dataframes.";
+        readonly description: "Validates the existence of accessed columns and rows of dataframes.";
         readonly defaultConfig: {
             readonly readLoadedData: false;
         };

package/linter/rules/dataframe-access-validation.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DATA_FRAME_ACCESS_VALIDATION = void 0;
-const absint_info_1 = require("../../abstract-interpretation/data-frame/absint-info");
 const shape_inference_1 = require("../../abstract-interpretation/data-frame/shape-inference");
 const satisfiable_domain_1 = require("../../abstract-interpretation/domains/satisfiable-domain");
 const config_1 = require("../../config");
@@ -28,14 +27,15 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
             })
         };
         const cfg = (0, extract_cfg_1.extractCfg)(data.normalize, ctx, data.dataflow.graph);
-        (0, shape_inference_1.inferDataFrameShapes)(cfg, data.dataflow.graph, data.normalize, ctx);
-        const accessOperations = getAccessOperations(elements);
+        const inference = new shape_inference_1.DataFrameShapeInferenceVisitor({ controlFlow: cfg, dfg: data.dataflow.graph, normalizedAst: data.normalize, ctx });
+        inference.start();
+        const accessOperations = getAccessOperations(elements, inference);
         const accesses = [];
         for (const [nodeId, operations] of accessOperations) {
             const access = { nodeId };
             for (const operation of operations) {
                 access.operand ??= operation.operand;
-                access.operandShape ??= (0, shape_inference_1.resolveIdToDataFrameShape)(operation.operand, data.dataflow.graph);
+                access.operandShape ??= inference.getAbstractValue(operation.operand);
                 if (operation.operation === 'accessCols' && operation.columns !== undefined) {
                     access.accessedCols ??= [];
                     access.accessedCols.push(...operation.columns);
@@ -85,17 +85,15 @@ exports.DATA_FRAME_ACCESS_VALIDATION = {
         tags: [linter_tags_1.LintingRuleTag.Bug, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
         // this rule is unable to detect all cases of dataframe access, but sufficiently ensures returned results are valid
         certainty: linter_format_1.LintingRuleCertainty.BestEffort,
-        description: 'Validates the existance of accessed columns and rows of dataframes.',
+        description: 'Validates the existence of accessed columns and rows of dataframes.',
         defaultConfig: { readLoadedData: false }
     }
 };
-function getAccessOperations(elements) {
+function getAccessOperations(elements, inference) {
     return new Map(elements.getElements()
-        .map(element => element.node)
-        .filter(absint_info_1.hasDataFrameExpressionInfo)
-        .map(node => [node.info.id, node.info.dataFrame.operations
-            .filter(({ operation }) => operation === 'accessCols' || operation === 'accessRows')
-            .map(({ operation, operand, type: _type, options: _options, ...args }) => ({ operation, operand, ...args }))
+        .map(element => [element.node.info.id, inference.getAbstractOperations(element.node.info.id)
+            ?.filter(({ operation }) => operation === 'accessCols' || operation === 'accessRows')
+            .map(({ operation, operand, type: _type, options: _options, ...args }) => ({ operation, operand, ...args })) ?? []
     ])
         .filter(([, operations]) => operations.length > 0));
 }

package/linter/rules/function-finder-util.d.ts

@@ -5,8 +5,8 @@ import type { FlowrSearchElement, FlowrSearchElements } from '../../search/flowr
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { MergeableRecord } from '../../util/objects';
 import type { DataflowInformation } from '../../dataflow/info';
-import type { FlowrConfigOptions } from '../../config';
 import type { FunctionInfo } from '../../queries/catalog/dependencies-query/function-info/function-info';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export interface FunctionsResult extends LintingResult {
     function: string;
     range: SourceRange;
@@ -41,6 +41,6 @@ export declare const functionFinderUtil: {
     requireArgumentValue(element: FlowrSearchElement<ParentInformation>, pool: readonly FunctionInfo[], data: {
         normalize: NormalizedAst;
         dataflow: DataflowInformation;
-        config: FlowrConfigOptions;
+        analyzer: ReadonlyFlowrAnalysisProvider;
     }, requireValue: RegExp | string | undefined): boolean;
 };

package/linter/rules/function-finder-util.js

@@ -65,7 +65,7 @@ exports.functionFinderUtil = {
         }
         const vert = data.dataflow.graph.getVertex(element.node.info.id);
         if ((0, vertex_1.isFunctionCallVertex)(vert)) {
-            const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue);
+            const args = (0, resolve_argument_1.getArgumentStringValue)(data.analyzer.flowrConfig.solver.variables, data.dataflow.graph, vert, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
             // we obtain all values, at least one of them has to trigger for the request
             const argValues = args ? args.values().flatMap(v => [...v]).filter(assert_1.isNotUndefined).toArray() : [];
             /* if there are no arguments we assume they may access the network, otherwise we check for the flag */

package/linter/rules/network-functions.js

@@ -7,7 +7,7 @@ const linter_tags_1 = require("../linter-tags");
 const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
 exports.NETWORK_FUNCTIONS = {
     createSearch: (config) => function_finder_util_1.functionFinderUtil.createSearch(config.fns),
-    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, { config: d.analyzer.flowrConfig, dataflow: d.dataflow, normalize: d.normalize }, c.onlyTriggerWithArgument))),
+    processSearchResult: (e, c, d) => function_finder_util_1.functionFinderUtil.processSearchResult(e, c, d, es => es.filter(e => function_finder_util_1.functionFinderUtil.requireArgumentValue(e, read_functions_1.ReadFunctions, { analyzer: d.analyzer, dataflow: d.dataflow, normalize: d.normalize }, c.onlyTriggerWithArgument))),
     prettyPrint: function_finder_util_1.functionFinderUtil.prettyPrint('network operations'),
     info: {
         name: 'Network Functions',

package/linter/rules/seeded-randomness.d.ts

@@ -31,7 +31,7 @@ export interface SeededRandomnessMeta extends MergeableRecord {
 }
 export declare const SEEDED_RANDOMNESS: {
     readonly createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "with"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
-    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: SeededRandomnessConfig, { dataflow }: {
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: SeededRandomnessConfig, { dataflow, analyzer }: {
         normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
         cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;

package/linter/rules/seeded-randomness.js

@@ -31,7 +31,7 @@ exports.SEEDED_RANDOMNESS = {
         { callName: config.randomnessProducers.filter(p => p.type === 'function').map(p => p.name) },
         { callName: getDefaultAssignments().flatMap(b => b.names), cascadeIf: () => cascade_action_1.CascadeAction.Continue }
     ]),
-    processSearchResult: (elements, config, { dataflow }) => {
+    processSearchResult: (elements, config, { dataflow, analyzer }) => {
         const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
         const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([n, a.config?.swapSourceAndTarget ? 1 : 0]))));
         const metadata = {
@@ -63,7 +63,7 @@ exports.SEEDED_RANDOMNESS = {
                 let otherBranch = false;
                 // function calls are already taken care of through the LastCall enrichment itself
                 for (const f of func ?? []) {
-                    if (isConstantArgument(dataflow.graph, f, 0)) {
+                    if (isConstantArgument(dataflow.graph, f, 0, analyzer.inspectContext())) {
                         const fCds = new Set(f.cds).difference(cds);
                         if (fCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(fCds)) {
                             metadata.callsWithFunctionProducers++;
@@ -83,7 +83,7 @@ exports.SEEDED_RANDOMNESS = {
                     const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
                     if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
                         // we either have arg index 0 or 1 for the assignmentProducers destination, so we select the assignment value as 1-argIdx here
-                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx)) {
+                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx, analyzer.inspectContext())) {
                             const aCds = new Set(a.cds).difference(cds);
                             if (aCds.size <= 0 || (0, info_1.happensInEveryBranchSet)(aCds)) {
                                 metadata.callsWithAssignmentProducers++;
@@ -132,9 +132,9 @@ exports.SEEDED_RANDOMNESS = {
 function getDefaultAssignments() {
     return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && b.processor == 'builtin:assignment');
 }
-function isConstantArgument(graph, call, argIndex) {
+function isConstantArgument(graph, call, argIndex, ctx) {
     const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
-    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias }));
+    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias, ctx }));
     return values?.elements.every(v => v.type === 'number' ||
         v.type === 'logical' ||
         v.type === 'string' ||

package/linter/rules/unused-definition.js

@@ -20,7 +20,7 @@ function getDefinitionArguments(def, dfg) {
 function buildQuickFix(variable, dfg, ast) {
     // first we check whether any of the 'Defined by' targets have any obligations - if so, we can not remove the definition
     // otherwise we can automatically remove the full definition!
-    if (variable.info.role === "accessed" /* RoleInParent.Accessed */ || variable.info.role === "for-variable" /* RoleInParent.ForVariable */) {
+    if (variable.info.role === "accessed" /* RoleInParent.Accessed */ || variable.info.role === "for-var" /* RoleInParent.ForVariable */) {
         // this is an access or a for variable, we can not remove it currently
         return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.6.3",
+  "version": "2.7.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -28,7 +28,6 @@
     "capabilities-markdown": "ts-node src/documentation/doc-capabilities.ts",
     "wiki": "ts-node src/cli/wiki.ts",
     "wiki:watch": "ts-node-dev src/cli/wiki.ts -- --keep-alive",
-    "wiki:linter": "ts-node src/documentation/wiki-linter.ts",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",

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

@@ -4,6 +4,8 @@ import { type FlowrAnalyzerPlugin, PluginType } from '../plugins/flowr-analyzer-
 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}).
@@ -18,10 +20,18 @@ 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;
+    /**
+     * Run all resolution steps that can be done before the main analysis run.
+     */
+    readonly resolvePreAnalysis: () => void;
 }
 /**
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
@@ -38,6 +48,7 @@ export interface ReadOnlyFlowrAnalyzerContext {
 export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContext {
     readonly files: FlowrAnalyzerFilesContext;
     readonly deps: FlowrAnalyzerDependenciesContext;
+    readonly env: FlowrAnalyzerEnvironmentContext;
     readonly config: FlowrConfigOptions;
     constructor(config: FlowrConfigOptions, plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
     /** delegate request addition */

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

@@ -11,6 +11,7 @@ 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})
@@ -26,12 +27,14 @@ const flowr_file_1 = require("./flowr-file");
 class FlowrAnalyzerContext {
     files;
     deps;
+    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) {

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

@@ -4,7 +4,8 @@ import type { FlowrAnalyzerLoadingOrderContext, ReadOnlyFlowrAnalyzerLoadingOrde
 import { FlowrAnalyzerProjectDiscoveryPlugin } from '../plugins/project-discovery/flowr-analyzer-project-discovery-plugin';
 import { FlowrAnalyzerFilePlugin } from '../plugins/file-plugins/flowr-analyzer-file-plugin';
 import { FlowrFile, type FlowrFileProvider, FileRole } from './flowr-file';
-import type { FlowrDescriptionFile } from '../plugins/file-plugins/flowr-description-file';
+import type { FlowrDescriptionFile } from '../plugins/file-plugins/files/flowr-description-file';
+import type { FlowrNewsFile } from '../plugins/file-plugins/files/flowr-news-file';
 /**
  * This is a request to process a folder as a project, which will be expanded by the registered {@link FlowrAnalyzerProjectDiscoveryPlugin}s.
  */
@@ -18,6 +19,7 @@ export interface RProjectAnalysisRequest {
 export type RAnalysisRequest = RParseRequest | RProjectAnalysisRequest;
 export type RoleBasedFiles = {
     [FileRole.Description]: FlowrDescriptionFile[];
+    [FileRole.News]: FlowrNewsFile[];
     [FileRole.Namespace]: FlowrFileProvider[];
     [FileRole.Source]: FlowrFileProvider[];
     [FileRole.Data]: FlowrFileProvider[];
@@ -45,6 +47,11 @@ export interface ReadOnlyFlowrAnalyzerFilesContext {
      * ```
      */
     getFilesByRole<Role extends FileRole>(role: Role): RoleBasedFiles[Role];
+    /**
+     * Get all files known to this context.
+     * @returns An array of all files.
+     */
+    getAllFiles(): FlowrFileProvider[];
     /**
      * 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
@@ -132,4 +139,5 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
      */
     computeLoadingOrder(): readonly RParseRequest[];
     getFilesByRole<Role extends FileRole>(role: Role): RoleBasedFiles[Role];
+    getAllFiles(): FlowrFileProvider[];
 }

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

@@ -42,6 +42,7 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
     /* files that are part of the analysis, e.g. source files */
     byRole = {
         [flowr_file_1.FileRole.Description]: [],
+        [flowr_file_1.FileRole.News]: [],
         [flowr_file_1.FileRole.Namespace]: [],
         [flowr_file_1.FileRole.Source]: [],
         [flowr_file_1.FileRole.Data]: [],
@@ -200,6 +201,9 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
     getFilesByRole(role) {
         return this.byRole[role];
     }
+    getAllFiles() {
+        return [...this.files.values(), ...this.inlineFiles];
+    }
 }
 exports.FlowrAnalyzerFilesContext = FlowrAnalyzerFilesContext;
 //# sourceMappingURL=flowr-analyzer-files-context.js.map

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

@@ -15,6 +15,8 @@ export declare enum FileRole {
     Description = "description",
     /** The `NAMESPACE` file in R packages, currently not specially supported. */
     Namespace = "namespace",
+    /** The `NEWS` file in R packages */
+    News = "news",
     /** Data files, e.g., `R/sysdata.rda`, currently not specially supported. */
     Data = "data",
     /**

package/project/context/flowr-file.js

@@ -17,6 +17,8 @@ var FileRole;
     FileRole["Description"] = "description";
     /** The `NAMESPACE` file in R packages, currently not specially supported. */
     FileRole["Namespace"] = "namespace";
+    /** The `NEWS` file in R packages */
+    FileRole["News"] = "news";
     /** Data files, e.g., `R/sysdata.rda`, currently not specially supported. */
     FileRole["Data"] = "data";
     /**

package/project/plugins/file-plugins/{flowr-description-file.d.ts → files/flowr-description-file.d.ts}

@@ -1,4 +1,4 @@
-import { type FlowrFileProvider, type FileRole, 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.

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrDescriptionFile = void 0;
+const flowr_file_1 = require("../../../context/flowr-file");
+/**
+ * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
+ */
+class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
+    wrapped;
+    /**
+     * 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) {
+        super(file.path(), file.role);
+        this.wrapped = file;
+    }
+    /**
+     * Loads and parses the content of the wrapped file as a DCF structure.
+     * @see {@link parseDCF} for details on the parsing logic.
+     */
+    loadContent() {
+        return parseDCF(this.wrapped);
+    }
+    /**
+     * Description file lifter, this does not re-create if already a description file
+     */
+    static from(file, role) {
+        if (role) {
+            file.assignRole(role);
+        }
+        return file instanceof FlowrDescriptionFile ? file : new FlowrDescriptionFile(file);
+    }
+}
+exports.FlowrDescriptionFile = FlowrDescriptionFile;
+/**
+ * Parses the given file in the 'Debian Control Format'.
+ * @param file - The file to parse
+ */
+function parseDCF(file) {
+    const result = new Map();
+    let currentKey = '';
+    let currentValue = '';
+    const indentRegex = new RegExp(/^\s/);
+    const firstColonRegex = new RegExp(/:(.*)/s);
+    const fileContent = file.content().toString().split(/\r?\n/);
+    for (const line of fileContent) {
+        if (indentRegex.test(line)) {
+            currentValue += '\n' + line.trim();
+        }
+        else {
+            if (currentKey) {
+                const values = currentValue ? cleanValues(currentValue) : [];
+                result.set(currentKey, values);
+            }
+            const [key, rest] = line.split(firstColonRegex).map(s => s.trim());
+            currentKey = key?.trim() ?? '';
+            currentValue = rest?.trim() ?? '';
+        }
+    }
+    if (currentKey) {
+        const values = currentValue ? cleanValues(currentValue) : [];
+        result.set(currentKey, values);
+    }
+    return result;
+}
+const cleanSplitRegex = /[\n,]+/;
+const cleanQuotesRegex = /'/g;
+function cleanValues(values) {
+    return values
+        .split(cleanSplitRegex)
+        .map(s => s.trim().replace(cleanQuotesRegex, ''))
+        .filter(s => s.length > 0);
+}
+//# sourceMappingURL=flowr-description-file.js.map

package/project/plugins/file-plugins/files/flowr-news-file.d.ts

@@ -0,0 +1,27 @@
+import { type FlowrFileProvider, type FileRole, FlowrFile } from '../../../context/flowr-file';
+export interface NewsChunk {
+    header?: string;
+    version?: string;
+    date?: string;
+    entries: string[] | NewsChunk[];
+}
+/**
+ * This decorates a text file and provides access to its content following R's NEWS file structure.
+ */
+export declare class FlowrNewsFile extends FlowrFile<NewsChunk[]> {
+    private readonly wrapped;
+    /**
+     * Prefer the static {@link FlowrNewsFile.from} method to create instances of this class as it will not re-create if already a news file
+     * and handle role assignments.
+     */
+    constructor(file: FlowrFileProvider);
+    /**
+     * Loads and parses the content of the wrapped file as news chunks.
+     * @see {@link parseNews} for details on the parsing logic.
+     */
+    protected loadContent(): NewsChunk[];
+    /**
+     * News file lifter, this does not re-create if already a news file
+     */
+    static from(file: FlowrFileProvider | FlowrNewsFile, role?: FileRole): FlowrNewsFile;
+}