@eagleoutice/flowr 2.4.8 → 2.6.0

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPlugin = exports.PluginType = void 0;
+const log_1 = require("../../util/log");
+/**
+ * Based on *when* and *what-for* the plugin is applied during the analysis,
+ * plugins are categorized into different types.
+ *
+ * Consult this diagram for an overview of orders and (implicit or explicit) dependencies:
+ *
+ * ```text
+ * ┌───────────┐   ┌───────────────────┐   ┌─────────────┐   ┌───────────────┐   ┌───────┐
+ * │           │   │                   │   │             │   │               │   │       │
+ * │ *Builder* ├──▶│ Project Discovery ├──▶│ File Loader ├──▶│ Dependencies  ├──▶│ *DFA* │
+ * │           │   │  (if necessary)   │   │             │   │   (static)    │   │       │
+ * └───────────┘   └───────────────────┘   └──────┬──────┘   └───────────────┘   └───────┘
+ *                                                │                                  ▲
+ *                                                │          ┌───────────────┐       │
+ *                                                │          │               │       │
+ *                                                └─────────▶│ Loading Order ├───────┘
+ *                                                           │               │
+ *                                                           └───────────────┘
+ *```
+ *
+ */
+var PluginType;
+(function (PluginType) {
+    /**
+     * Plugins that are applied right after the builder has been created and before any analysis is done.
+     * @see {@link FlowrAnalyzerPackageVersionsPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["DependencyIdentification"] = "package-versions";
+    /**
+     * Plugins that are used to determine the order in which files are loaded and analyzed.
+     * @see {@link FlowrAnalyzerLoadingOrderPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["LoadingOrder"] = "loading-order";
+    /**
+     * Plugins that are applied to discover the project structure, files, and folders to analyze.
+     * @see {@link FlowrAnalyzerProjectDiscoveryPlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["ProjectDiscovery"] = "project-discovery";
+    /**
+     * Plugins that are applied to load and parse files.
+     * @see {@link FlowrAnalyzerFilePlugin} - for the base class to implement such a plugin.
+     */
+    PluginType["FileLoad"] = "file-load";
+})(PluginType || (exports.PluginType = PluginType = {}));
+const generalPluginLog = log_1.log.getSubLogger({ name: 'plugins' });
+/**
+ * The base class every plugin to be used with the {@link FlowrAnalyzer} must extend.
+ * **Please do not create plugins directly based on this class, but use the classes referenced alongside the {@link PluginType} values!**
+ * For example, if you want to create a plugin that determines the loading order of files, extend {@link FlowrAnalyzerLoadingOrderPlugin} instead.
+ * These classes also provide sensible overrides of {@link FlowrAnalyzerPlugin.defaultPlugin} to be used when no plugin of this type is registered or triggered.
+ */
+class FlowrAnalyzerPlugin {
+    /**
+     * Returns a default/dummy implementation to be used when no plugin of this type is registered or triggered.
+     */
+    static defaultPlugin() {
+        throw new Error('This is to be implemented by every Plugin Layer');
+    }
+    /**
+     * Run the plugin with the given context and arguments.
+     */
+    processor(context, args) {
+        const now = Date.now();
+        try {
+            const result = this.process(context, args);
+            const duration = Date.now() - now;
+            (0, log_1.expensiveTrace)(generalPluginLog, () => `Plugin ${this.name} (v${this.version.format()}, ${this.type}) executed in ${duration}ms.`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - now;
+            generalPluginLog.error(`Plugin ${this.name} (v${this.version.format()}, {this.type}) failed after ${duration}ms. Error: ${error.message}`);
+            throw error;
+        }
+    }
+}
+exports.FlowrAnalyzerPlugin = FlowrAnalyzerPlugin;
+//# sourceMappingURL=flowr-analyzer-plugin.js.map

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

@@ -0,0 +1,14 @@
+import { SemVer } from 'semver';
+import { FlowrAnalyzerLoadingOrderPlugin } from './flowr-analyzer-loading-order-plugin';
+import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
+/**
+ * This plugin extracts loading order information from R `DESCRIPTION` files.
+ * It looks at the `Collate` field to determine the order in which files should be loaded.
+ * If no `Collate` field is present, it does nothing.
+ */
+export declare class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends FlowrAnalyzerLoadingOrderPlugin {
+    readonly name = "flowr-analyzer-package-version-description-file-plugin";
+    readonly description = "This plugin determines loading order based on the Collate field in DESCRIPTION files.";
+    readonly version: SemVer;
+    process(ctx: FlowrAnalyzerContext): void;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerLoadingOrderDescriptionFilePlugin = void 0;
+const flowr_analyzer_description_file_plugin_1 = require("../file-plugins/flowr-analyzer-description-file-plugin");
+const semver_1 = require("semver");
+const flowr_analyzer_loading_order_plugin_1 = require("./flowr-analyzer-loading-order-plugin");
+const flowr_file_1 = require("../../context/flowr-file");
+/**
+ * This plugin extracts loading order information from R `DESCRIPTION` files.
+ * It looks at the `Collate` field to determine the order in which files should be loaded.
+ * If no `Collate` field is present, it does nothing.
+ */
+class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends flowr_analyzer_loading_order_plugin_1.FlowrAnalyzerLoadingOrderPlugin {
+    name = 'flowr-analyzer-package-version-description-file-plugin';
+    description = 'This plugin determines loading order based on the Collate field in DESCRIPTION files.';
+    version = new semver_1.SemVer('0.1.0');
+    process(ctx) {
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        if (descFiles.length !== 1) {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
+            return;
+        }
+        /** this will do the caching etc. for me */
+        const deps = descFiles[0].content();
+        if (deps.has('Collate')) {
+            const collate = deps.get('Collate') ?? [];
+            /* we probably have to do some more guesswork here */
+            const unordered = ctx.files.loadingOrder.getUnorderedRequests();
+            // sort them by their path index in the Collate field
+            const sorted = unordered.slice().sort((a, b) => {
+                const aPath = a.request === 'file' ? a.content : undefined;
+                const bPath = b.request === 'file' ? b.content : undefined;
+                const aIndex = aPath ? collate.findIndex(c => aPath.endsWith(c.trim())) : -1;
+                const bIndex = bPath ? collate.findIndex(c => bPath.endsWith(c.trim())) : -1;
+                if (aIndex === -1 && bIndex === -1) {
+                    return 0; // both not found, keep original order
+                }
+                else if (aIndex === -1) {
+                    return 1; // a not found, b found -> a after b
+                }
+                else if (bIndex === -1) {
+                    return -1; // b not found, a found -> a before b
+                }
+                else {
+                    return aIndex - bIndex; // both found, sort by index
+                }
+            });
+            ctx.files.loadingOrder.addGuess(sorted, true);
+        }
+        else {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.info(`No Collate field in DESCRIPTION file ${descFiles[0].path().toString()}`);
+        }
+    }
+}
+exports.FlowrAnalyzerLoadingOrderDescriptionFilePlugin = FlowrAnalyzerLoadingOrderDescriptionFilePlugin;
+//# sourceMappingURL=flowr-analyzer-loading-order-description-file-plugin.js.map

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-plugin.d.ts

@@ -0,0 +1,13 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+/**
+ * This is the base class for all plugins that determine the loading order of files in a project.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project and determine their loading order.
+ * See {@link DefaultFlowrAnalyzerLoadingOrderPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a full project analysis after all files have been discovered and loaded.
+ * Otherwise, they may trigger multiple times (if for some reason, discovery reveals new files during the analysis).
+ */
+export declare abstract class FlowrAnalyzerLoadingOrderPlugin extends FlowrAnalyzerPlugin<undefined, void> {
+    readonly type = PluginType.LoadingOrder;
+    static defaultPlugin(): FlowrAnalyzerLoadingOrderPlugin;
+}

package/project/plugins/loading-order-plugins/flowr-analyzer-loading-order-plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerLoadingOrderPlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+/**
+ * This is the base class for all plugins that determine the loading order of files in a project.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project and determine their loading order.
+ * See {@link DefaultFlowrAnalyzerLoadingOrderPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a full project analysis after all files have been discovered and loaded.
+ * Otherwise, they may trigger multiple times (if for some reason, discovery reveals new files during the analysis).
+ */
+class FlowrAnalyzerLoadingOrderPlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.LoadingOrder;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerLoadingOrderPlugin();
+    }
+}
+exports.FlowrAnalyzerLoadingOrderPlugin = FlowrAnalyzerLoadingOrderPlugin;
+/**
+ * This is the default dummy implementation of the {@link FlowrAnalyzerLoadingOrderPlugin}.
+ * It does nothing and relies on the chronological order of file discovery.
+ */
+class DefaultFlowrAnalyzerLoadingOrderPlugin extends FlowrAnalyzerLoadingOrderPlugin {
+    name = 'default-loading-order-plugin';
+    description = 'This is the default loading order plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    process() {
+        /* we always *have* to have a loading order, this plugin does not have to guess to rely on chronological order */
+    }
+}
+//# sourceMappingURL=flowr-analyzer-loading-order-plugin.js.map

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

@@ -0,0 +1,14 @@
+import { FlowrAnalyzerPackageVersionsPlugin } from './flowr-analyzer-package-versions-plugin';
+import { SemVer } from 'semver';
+import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
+/**
+ * This plugin extracts package versions from R `DESCRIPTION` files.
+ * It looks at the `Depends` and `Imports` fields to find package names and their version constraints.
+ */
+export declare class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends FlowrAnalyzerPackageVersionsPlugin {
+    readonly name = "flowr-analyzer-package-version-description-file-plugin";
+    readonly description = "This plugin does...";
+    readonly version: SemVer;
+    process(ctx: FlowrAnalyzerContext): void;
+    private retrieveVersionsFromField;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPackageVersionsDescriptionFilePlugin = void 0;
+const flowr_analyzer_package_versions_plugin_1 = require("./flowr-analyzer-package-versions-plugin");
+const flowr_analyzer_description_file_plugin_1 = require("../file-plugins/flowr-analyzer-description-file-plugin");
+const semver_1 = require("semver");
+const package_1 = require("./package");
+const flowr_file_1 = require("../../context/flowr-file");
+const VersionRegex = /^([a-zA-Z0-9.]+)(?:\s*\(([><=~!]+)\s*([\d.]+)\))?$/;
+/**
+ * This plugin extracts package versions from R `DESCRIPTION` files.
+ * It looks at the `Depends` and `Imports` fields to find package names and their version constraints.
+ */
+class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends flowr_analyzer_package_versions_plugin_1.FlowrAnalyzerPackageVersionsPlugin {
+    name = 'flowr-analyzer-package-version-description-file-plugin';
+    description = 'This plugin does...';
+    version = new semver_1.SemVer('0.1.0');
+    process(ctx) {
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        if (descFiles.length !== 1) {
+            flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
+            return;
+        }
+        /** this will do the caching etc. for me */
+        const deps = descFiles[0].content();
+        this.retrieveVersionsFromField(ctx, deps, 'Depends', 'r');
+        this.retrieveVersionsFromField(ctx, deps, 'Imports', 'package');
+    }
+    retrieveVersionsFromField(ctx, file, field, type) {
+        for (const entry of file.get(field) ?? []) {
+            const match = VersionRegex.exec(entry);
+            if (match) {
+                const [, name, operator, version] = match;
+                const range = package_1.Package.parsePackageVersionRange(operator, version);
+                ctx.deps.addDependency(new package_1.Package(name, type, undefined, range));
+            }
+        }
+    }
+}
+exports.FlowrAnalyzerPackageVersionsDescriptionFilePlugin = FlowrAnalyzerPackageVersionsDescriptionFilePlugin;
+//# sourceMappingURL=flowr-analyzer-package-versions-description-file-plugin.js.map

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-plugin.d.ts

@@ -0,0 +1,10 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+/**
+ * This is the base class for all plugins that identify package and dependency versions used in the project.
+ * These plugins interplay with the {@link FlowrAnalyzerDependenciesContext} to gather information about the packages used in the project.
+ * See {@link DefaultFlowrAnalyzerPackageVersionsPlugin} for the no-op default implementation.
+ */
+export declare abstract class FlowrAnalyzerPackageVersionsPlugin extends FlowrAnalyzerPlugin<undefined, void> {
+    readonly type = PluginType.DependencyIdentification;
+    static defaultPlugin(): FlowrAnalyzerPackageVersionsPlugin;
+}

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-plugin.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPackageVersionsPlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+/**
+ * This is the base class for all plugins that identify package and dependency versions used in the project.
+ * These plugins interplay with the {@link FlowrAnalyzerDependenciesContext} to gather information about the packages used in the project.
+ * See {@link DefaultFlowrAnalyzerPackageVersionsPlugin} for the no-op default implementation.
+ */
+class FlowrAnalyzerPackageVersionsPlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.DependencyIdentification;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerPackageVersionsPlugin();
+    }
+}
+exports.FlowrAnalyzerPackageVersionsPlugin = FlowrAnalyzerPackageVersionsPlugin;
+/**
+ * This is the default no-op implementation of the {@link FlowrAnalyzerPackageVersionsPlugin}.
+ */
+class DefaultFlowrAnalyzerPackageVersionsPlugin extends FlowrAnalyzerPackageVersionsPlugin {
+    name = 'default-package-versions-plugin';
+    description = 'This is the default package versions plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    process() {
+        /* we do not need package versions for the analysis to do things! */
+    }
+}
+//# sourceMappingURL=flowr-analyzer-package-versions-plugin.js.map

package/project/plugins/package-version-plugins/package.d.ts

@@ -0,0 +1,15 @@
+import { Range } from 'semver';
+export type PackageType = 'package' | 'system' | 'r';
+export declare class Package {
+    name: string;
+    derivedVersion?: Range;
+    type?: PackageType;
+    dependencies?: Package[];
+    versionConstraints: Range[];
+    constructor(name: string, type?: PackageType, dependencies?: Package[], ...versionConstraints: readonly (Range | undefined)[]);
+    mergeInPlace(other: Package): void;
+    addInfo(type?: PackageType, dependencies?: Package[], ...versionConstraints: readonly Range[]): void;
+    getInfo(): this;
+    deriveVersion(): Range | undefined;
+    static parsePackageVersionRange(constraint?: string, version?: string): Range | undefined;
+}

package/project/plugins/package-version-plugins/package.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Package = void 0;
+const semver_1 = require("semver");
+const assert_1 = require("../../../util/assert");
+class Package {
+    name;
+    derivedVersion;
+    type;
+    dependencies;
+    versionConstraints = [];
+    constructor(name, type, dependencies, ...versionConstraints) {
+        this.name = name;
+        this.addInfo(type, dependencies, ...(versionConstraints ?? []).filter(assert_1.isNotUndefined));
+    }
+    mergeInPlace(other) {
+        (0, assert_1.guard)(this.name === other.name, 'Can only merge packages with the same name');
+        this.addInfo(other.type, other.dependencies, ...other.versionConstraints);
+    }
+    addInfo(type, dependencies, ...versionConstraints) {
+        if (type !== undefined) {
+            this.type = type;
+        }
+        if (dependencies !== undefined) {
+            this.dependencies = dependencies;
+        }
+        if (versionConstraints !== undefined) {
+            this.derivedVersion ??= versionConstraints[0];
+            for (const constraint of versionConstraints) {
+                if (!this.derivedVersion?.intersects(constraint)) {
+                    throw Error('Version constraint mismatch!');
+                }
+                this.versionConstraints.push(constraint);
+                this.derivedVersion = this.deriveVersion();
+            }
+        }
+    }
+    getInfo() {
+        return this;
+    }
+    deriveVersion() {
+        return this.versionConstraints.length > 0
+            ? new semver_1.Range(this.versionConstraints.map(c => c.raw).join(' '))
+            : undefined;
+    }
+    static parsePackageVersionRange(constraint, version) {
+        if (version) {
+            return constraint ? new semver_1.Range(constraint + version) : new semver_1.Range(version);
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+exports.Package = Package;
+//# sourceMappingURL=package.js.map

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

@@ -0,0 +1,15 @@
+import { FlowrAnalyzerPlugin, PluginType } from '../flowr-analyzer-plugin';
+import type { RParseRequest } from '../../../r-bridge/retriever';
+import type { RProjectAnalysisRequest } from '../../context/flowr-analyzer-files-context';
+import type { FlowrFile } from '../../context/flowr-file';
+/**
+ * This is the base class for all plugins that discover files in a project for analysis.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project.
+ * See {@link DefaultFlowrAnalyzerProjectDiscoveryPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a {@link RProjectAnalysisRequest} with the idea to discover all files in a project.
+ */
+export declare abstract class FlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerPlugin<RProjectAnalysisRequest, (RParseRequest | FlowrFile<string>)[]> {
+    readonly type = PluginType.ProjectDiscovery;
+    static defaultPlugin(): FlowrAnalyzerProjectDiscoveryPlugin;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerProjectDiscoveryPlugin = void 0;
+const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
+const semver_1 = require("semver");
+const flowr_file_1 = require("../../context/flowr-file");
+const files_1 = require("../../../util/files");
+/**
+ * This is the base class for all plugins that discover files in a project for analysis.
+ * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project.
+ * See {@link DefaultFlowrAnalyzerProjectDiscoveryPlugin} for the dummy default implementation.
+ *
+ * In general, these plugins only trigger for a {@link RProjectAnalysisRequest} with the idea to discover all files in a project.
+ */
+class FlowrAnalyzerProjectDiscoveryPlugin extends flowr_analyzer_plugin_1.FlowrAnalyzerPlugin {
+    type = flowr_analyzer_plugin_1.PluginType.ProjectDiscovery;
+    static defaultPlugin() {
+        return new DefaultFlowrAnalyzerProjectDiscoveryPlugin();
+    }
+}
+exports.FlowrAnalyzerProjectDiscoveryPlugin = FlowrAnalyzerProjectDiscoveryPlugin;
+/**
+ * This is the default dummy implementation of the {@link FlowrAnalyzerProjectDiscoveryPlugin}.
+ * It simply collects all files in the given folder and returns them as either {@link RParseRequest} (for R and Rmd files) or {@link FlowrTextFile} (for all other files).
+ */
+class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDiscoveryPlugin {
+    name = 'default-project-discovery-plugin';
+    description = 'This is the default project discovery plugin that does nothing.';
+    version = new semver_1.SemVer('0.0.0');
+    process(_context, args) {
+        const requests = [];
+        /* the dummy approach of collecting all files, group R and Rmd files, and be done with it */
+        for (const file of (0, files_1.getAllFilesSync)(args.content)) {
+            if (file.endsWith('.R') || file.endsWith('.r') || file.endsWith('.Rmd') || file.endsWith('.rmd')) {
+                requests.push({ content: file, request: 'file' });
+            }
+            else {
+                requests.push(new flowr_file_1.FlowrTextFile(file));
+            }
+        }
+        return requests;
+    }
+}
+//# sourceMappingURL=flowr-analyzer-project-discovery-plugin.js.map

package/queries/base-query-format.d.ts

@@ -1,7 +1,4 @@
-import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataflowInformation } from '../dataflow/info';
-import type { FlowrConfigOptions } from '../config';
-import type { SemVer } from 'semver';
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -14,8 +11,5 @@ export interface BaseQueryResult {
     readonly '.meta': BaseQueryMeta;
 }
 export interface BasicQueryData {
-    readonly lib?: Record<string, SemVer>;
-    readonly ast: NormalizedAst;
-    readonly dataflow: DataflowInformation;
-    readonly config: FlowrConfigOptions;
+    readonly analyzer: FlowrAnalysisProvider;
 }

package/queries/catalog/call-context-query/call-context-query-executor.d.ts

@@ -13,4 +13,4 @@ export type PromotedLinkTo = Omit<LinkTo, 'callName'> & {
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-export declare function executeCallContextQueries({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;
+export declare function executeCallContextQueries({ analyzer }: BasicQueryData, queries: readonly CallContextQuery[]): Promise<CallContextQueryResult>;

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -5,7 +5,6 @@ exports.executeCallContextQueries = executeCallContextQueries;
 const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const edge_1 = require("../../../dataflow/graph/edge");
-const extract_cfg_1 = require("../../../control-flow/extract-cfg");
 const two_layer_collector_1 = require("../../two-layer-collector");
 const objects_1 = require("../../../util/objects");
 const identify_link_to_last_call_relation_1 = require("./identify-link-to-last-call-relation");
@@ -15,7 +14,7 @@ function isQuoted(node, graph) {
     if (vertex === undefined) {
         return false;
     }
-    return [...vertex.values()].some(({ types }) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.NonStandardEvaluation));
+    return vertex.values().some(({ types }) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.NonStandardEvaluation));
 }
 function makeReport(collector) {
     const result = {};
@@ -109,9 +108,10 @@ function retrieveAllCallAliases(nodeId, graph) {
         }
         const [info, outgoing] = vertex;
         if (info.tag !== vertex_1.VertexType.FunctionCall) {
-            const x = [...outgoing]
+            const x = outgoing.entries()
                 .filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall))
-                .map(([t]) => [(0, node_id_1.recoverContent)(t, graph) ?? '', t]);
+                .map(([t]) => [(0, node_id_1.recoverContent)(t, graph) ?? '', t])
+                .toArray();
             /** only follow defined-by and reads */
             queue = queue.concat(x);
             continue;
@@ -120,7 +120,7 @@ function retrieveAllCallAliases(nodeId, graph) {
         if (id !== nodeId) {
             track |= edge_1.EdgeType.Returns;
         }
-        const out = [...outgoing]
+        const out = outgoing.entries()
             .filter(([, e]) => (0, edge_1.edgeIncludesType)(e.types, track) && (nodeId !== id || !(0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Argument)))
             .map(([t]) => t);
         for (const call of out) {
@@ -173,7 +173,9 @@ function isParameterDefaultValue(nodeId, ast) {
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries) {
+async function executeCallContextQueries({ analyzer }, queries) {
+    const dataflow = await analyzer.dataflow();
+    const ast = await analyzer.normalize();
     /* omit performance page load */
     const now = Date.now();
     /* the node id and call targets if present */
@@ -182,10 +184,10 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
     const { promotedQueries, requiresCfg } = promoteQueryCallNames(queries);
     let cfg = undefined;
     if (requiresCfg) {
-        cfg = (0, extract_cfg_1.extractCfg)(ast, config, graph, []);
+        cfg = await analyzer.controlflow([], true);
     }
     const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
-    for (const [nodeId, info] of graph.vertices(true)) {
+    for (const [nodeId, info] of dataflow.graph.vertices(true)) {
         if (info.tag !== vertex_1.VertexType.FunctionCall) {
             continue;
         }
@@ -196,7 +198,7 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
              * by checking all of these queries would be satisfied otherwise,
              * in general, we first want a call to happen, i.e., trace the called targets of this!
              */
-            const targets = retrieveAllCallAliases(nodeId, graph);
+            const targets = retrieveAllCallAliases(nodeId, dataflow.graph);
             for (const [l, ids] of targets.entries()) {
                 for (const query of queriesWhichWantAliases) {
                     if (query.callName instanceof RegExp ? query.callName.test(l) : query.callName.has(l)) {
@@ -212,12 +214,12 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
             }
             let targets = undefined;
             if (query.callTargets) {
-                targets = (0, identify_link_to_last_call_relation_1.satisfiesCallTargets)(nodeId, graph, query.callTargets);
+                targets = (0, identify_link_to_last_call_relation_1.satisfiesCallTargets)(nodeId, dataflow.graph, query.callTargets);
                 if (targets === 'no') {
                     continue;
                 }
             }
-            if (isQuoted(nodeId, graph)) {
+            if (isQuoted(nodeId, dataflow.graph)) {
                 /* if the call is quoted, we do not want to link to it */
                 continue;
             }
@@ -229,7 +231,7 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
                 const linked = Array.isArray(query.linkTo) ? query.linkTo : [query.linkTo];
                 for (const link of linked) {
                     /* if we have a linkTo query, we have to find the last call */
-                    const lastCall = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(nodeId, cfg.graph, graph, link);
+                    const lastCall = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(nodeId, cfg.graph, dataflow.graph, link);
                     if (lastCall) {
                         linkedIds ??= new Set();
                         for (const l of lastCall) {
@@ -243,7 +245,12 @@ function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries
                     }
                 }
             }
-            initialIdCollector.add(query.kind ?? '.', query.subkind ?? '.', (0, objects_1.compactRecord)({ id: nodeId, name: info.name, calls: targets, linkedIds: linkedIds ? [...linkedIds] : undefined }));
+            initialIdCollector.add(query.kind ?? '.', query.subkind ?? '.', (0, objects_1.compactRecord)({
+                id: nodeId,
+                name: info.name,
+                calls: targets,
+                linkedIds: linkedIds ? [...linkedIds] : undefined
+            }));
         }
     }
     removeIdenticalDuplicates(initialIdCollector);

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -3,13 +3,12 @@ import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/nod
 import { executeCallContextQueries } from './call-context-query-executor';
 import type { OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
-import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
-import type { DEFAULT_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import { CallTargets } from './identify-link-to-last-call-relation';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 import type { DataflowGraphVertexInfo } from '../../../dataflow/graph/vertex';
 import type { CascadeAction } from './cascade-action';
 import type { NoInfo } from '../../../r-bridge/lang-4.x/ast/model/model';
+import type { FlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 export interface FileFilter<FilterType> {
     /**
      * Regex that a node's file attribute must match to be considered
@@ -109,7 +108,7 @@ export interface CallContextQueryResult extends BaseQueryResult {
 export type CallContextQuery<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> = DefaultCallContextQueryFormat<CallName> | SubCallContextQueryFormat<CallName, AttachLinkInfo>;
 export declare const CallContextQueryDefinition: {
     readonly executor: typeof executeCallContextQueries;
-    readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/call-context-query/call-context-query-format.js

@@ -19,10 +19,10 @@ const CallContextQueryLinkTo = joi_1.default.object({
 });
 exports.CallContextQueryDefinition = {
     executor: call_context_query_executor_1.executeCallContextQueries,
-    asciiSummarizer: (formatter, processed, queryResults, result) => {
+    asciiSummarizer: async (formatter, analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('call-context', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push((0, query_print_1.asciiCallContext)(formatter, out, processed));
+        result.push((0, query_print_1.asciiCallContext)(formatter, out, (await analyzer.normalize()).idMap));
         return true;
     },
     schema: joi_1.default.object({

package/queries/catalog/cluster-query/cluster-query-executor.d.ts

@@ -1,3 +1,3 @@
 import type { DataflowClusterQuery, DataflowClusterQueryResult } from './cluster-query-format';
 import type { BasicQueryData } from '../../base-query-format';
-export declare function executeDataflowClusterQuery({ dataflow: { graph } }: BasicQueryData, queries: readonly DataflowClusterQuery[]): DataflowClusterQueryResult;
+export declare function executeDataflowClusterQuery({ analyzer }: BasicQueryData, queries: readonly DataflowClusterQuery[]): Promise<DataflowClusterQueryResult>;

package/queries/catalog/cluster-query/cluster-query-executor.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDataflowClusterQuery = executeDataflowClusterQuery;
 const log_1 = require("../../../util/log");
 const cluster_1 = require("../../../dataflow/cluster");
-function executeDataflowClusterQuery({ dataflow: { graph } }, queries) {
+async function executeDataflowClusterQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('The dataflow cluster query expects only up to one query, but got', queries.length);
     }
     const start = Date.now();
-    const clusters = (0, cluster_1.findAllClusters)(graph);
+    const clusters = (0, cluster_1.findAllClusters)((await analyzer.dataflow()).graph);
     return {
         '.meta': {
             timing: Date.now() - start