@eagleoutice/flowr 2.6.2 → 2.7.0

package/project/plugins/file-plugins/notebooks/flowr-rmarkdown-file.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrRMarkdownFile = void 0;
+exports.parseRMarkdownFile = parseRMarkdownFile;
+exports.isRCodeBlock = isRCodeBlock;
+exports.restoreBlocksWithoutMd = restoreBlocksWithoutMd;
+exports.parseCodeBlockOptions = parseCodeBlockOptions;
+const flowr_file_1 = require("../../../context/flowr-file");
+const assert_1 = require("../../../../util/assert");
+const commonmark_1 = require("commonmark");
+const gray_matter_1 = __importDefault(require("gray-matter"));
+/**
+ * This decorates a text file and parses its contents as a R Markdown file.
+ * Finnaly, it provides access to the single cells, and all cells fused together as one R file.
+ */
+class FlowrRMarkdownFile extends flowr_file_1.FlowrFile {
+    data;
+    wrapped;
+    /**
+     * Prefer the static {@link FlowrRMarkdownFile.from} method
+     * @param file - the file to load as R Markdown
+     */
+    constructor(file) {
+        super(file.path(), flowr_file_1.FileRole.Source);
+        this.wrapped = file;
+    }
+    get rmd() {
+        if (!this.data) {
+            this.loadContent();
+        }
+        (0, assert_1.guard)(this.data);
+        return this.data;
+    }
+    /**
+     * Loads and parses the content of the wrapped file.
+     * @returns RmdInfo
+     */
+    loadContent() {
+        this.data = parseRMarkdownFile(this.wrapped.content());
+        return this.data.content;
+    }
+    static from(file) {
+        return file instanceof FlowrRMarkdownFile ? file : new FlowrRMarkdownFile(file);
+    }
+}
+exports.FlowrRMarkdownFile = FlowrRMarkdownFile;
+/**
+ * Parse the contents of a RMarkdown file into complete code and blocks
+ * @param raw - the raw file content
+ * @returns Rmd Info
+ */
+function parseRMarkdownFile(raw) {
+    // Read and Parse Markdown
+    const parser = new commonmark_1.Parser();
+    const ast = parser.parse(raw);
+    // Parse Frontmatter
+    const frontmatter = (0, gray_matter_1.default)(raw);
+    // Parse Codeblocks
+    const walker = ast.walker();
+    const blocks = [];
+    let e;
+    while ((e = walker.next())) {
+        const node = e.node;
+        if (!isRCodeBlock(node)) {
+            continue;
+        }
+        blocks.push({
+            code: node.literal,
+            options: parseCodeBlockOptions(node.info, node.literal),
+            startpos: { line: node.sourcepos[0][0] + 1, col: 0 }
+        });
+    }
+    return {
+        content: restoreBlocksWithoutMd(blocks, countNewlines(raw)),
+        // eslint-disable-next-line unused-imports/no-unused-vars
+        blocks: blocks.map(({ startpos, ...block }) => block),
+        options: frontmatter.data
+    };
+}
+const RTagRegex = /{[rR](?:[\s,][^}]*)?}/;
+/**
+ * Checks whether a CommonMark node is an R code block
+ */
+function isRCodeBlock(node) {
+    return node.type === 'code_block' && node.literal !== null && node.info !== null && RTagRegex.test(node.info);
+}
+const LineRegex = /\r\n|\r|\n/;
+function countNewlines(str) {
+    return str.split(LineRegex).length - 1;
+}
+/**
+ * Restores an Rmd file from code blocks, filling non-code lines with empty lines
+ */
+function restoreBlocksWithoutMd(blocks, totalLines) {
+    let line = 1;
+    let output = '';
+    const goToLine = (n) => {
+        const diff = n - line;
+        (0, assert_1.guard)(diff >= 0);
+        line += diff;
+        output += '\n'.repeat(diff);
+    };
+    for (const block of blocks) {
+        goToLine(block.startpos.line);
+        output += block.code;
+        line += countNewlines(block.code);
+    }
+    // Add remainder of file
+    goToLine(totalLines + 1);
+    return output;
+}
+/**
+ * Parses the options of an R code block from its header and content
+ */
+function parseCodeBlockOptions(header, content) {
+    let opts = header.length === 3 // '{r}' => header.length=3 (no options in header)
+        ? ''
+        : header.substring(3, header.length - 1).trim();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line.trim().startsWith('#|')) {
+            break;
+        }
+        const opt = line.substring(3);
+        opts += opts.length === 0 ? opt : `, ${opt}`;
+    }
+    return opts;
+}
+//# sourceMappingURL=flowr-rmarkdown-file.js.map

package/project/plugins/file-plugins/notebooks/notebook.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=notebook.js.map

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

@@ -0,0 +1,5 @@
+import type { FlowrAnalyzerPlugin } from './flowr-analyzer-plugin';
+/**
+ * Provides the default set of Flowr Analyzer plugins.
+ */
+export declare function FlowrAnalyzerPluginDefaults(): FlowrAnalyzerPlugin[];

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrAnalyzerPluginDefaults = FlowrAnalyzerPluginDefaults;
+const flowr_analyzer_description_file_plugin_1 = require("./file-plugins/flowr-analyzer-description-file-plugin");
+const flowr_analyzer_package_versions_description_file_plugin_1 = require("./package-version-plugins/flowr-analyzer-package-versions-description-file-plugin");
+const flowr_analyzer_loading_order_description_file_plugin_1 = require("./loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin");
+const flowr_analyzer_rmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-rmd-file-plugin");
+const flowr_analyzer_qmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-qmd-file-plugin");
+const flowr_analyzer_jupyter_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin");
+/**
+ * Provides the default set of Flowr Analyzer plugins.
+ */
+function FlowrAnalyzerPluginDefaults() {
+    return [
+        new flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin(),
+        new flowr_analyzer_package_versions_description_file_plugin_1.FlowrAnalyzerPackageVersionsDescriptionFilePlugin(),
+        new flowr_analyzer_loading_order_description_file_plugin_1.FlowrAnalyzerLoadingOrderDescriptionFilePlugin(),
+        new flowr_analyzer_rmd_file_plugin_1.FlowrAnalyzerRmdFilePlugin(),
+        new flowr_analyzer_qmd_file_plugin_1.FlowrAnalyzerQmdFilePlugin(),
+        new flowr_analyzer_jupyter_file_plugin_1.FlowrAnalyzerJupyterFilePlugin(),
+    ];
+}
+//# sourceMappingURL=flowr-analyzer-plugin-defaults.js.map

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

@@ -72,6 +72,8 @@ export interface FlowrAnalyzerPluginInterface<In = unknown, Out = In> {
  * **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.
+ *
+ * For a collection of default plugins, see {@link FlowrAnalyzerPluginDefaults}.
  */
 export declare abstract class FlowrAnalyzerPlugin<In = unknown, Out extends AsyncOrSync<unknown> = In> implements FlowrAnalyzerPluginInterface<In, Out> {
     abstract readonly name: string;

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

@@ -52,6 +52,8 @@ const generalPluginLog = log_1.log.getSubLogger({ name: 'plugins' });
  * **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.
+ *
+ * For a collection of default plugins, see {@link FlowrAnalyzerPluginDefaults}.
  */
 class FlowrAnalyzerPlugin {
     /**

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

@@ -15,7 +15,7 @@ class FlowrAnalyzerLoadingOrderDescriptionFilePlugin extends flowr_analyzer_load
     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);
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.FileRole.Description);
         if (descFiles.length !== 1) {
             flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
             return;

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

@@ -16,7 +16,7 @@ class FlowrAnalyzerPackageVersionsDescriptionFilePlugin extends flowr_analyzer_p
     description = 'This plugin does...';
     version = new semver_1.SemVer('0.1.0');
     process(ctx) {
-        const descFiles = ctx.files.getFilesByRole(flowr_file_1.SpecialFileRole.Description);
+        const descFiles = ctx.files.getFilesByRole(flowr_file_1.FileRole.Description);
         if (descFiles.length !== 1) {
             flowr_analyzer_description_file_plugin_1.descriptionFileLog.warn(`Supporting only exactly one DESCRIPTION file, found ${descFiles.length}`);
             return;

package/project/plugins/plugin-registry.d.ts

@@ -0,0 +1,34 @@
+import type { FlowrAnalyzerPlugin } from './flowr-analyzer-plugin';
+import { FlowrAnalyzerDescriptionFilePlugin } from './file-plugins/flowr-analyzer-description-file-plugin';
+import { FlowrAnalyzerPackageVersionsDescriptionFilePlugin } from './package-version-plugins/flowr-analyzer-package-versions-description-file-plugin';
+import { FlowrAnalyzerLoadingOrderDescriptionFilePlugin } from './loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin';
+import { FlowrAnalyzerRmdFilePlugin } from './file-plugins/notebooks/flowr-analyzer-rmd-file-plugin';
+import { FlowrAnalyzerQmdFilePlugin } from './file-plugins/notebooks/flowr-analyzer-qmd-file-plugin';
+import { FlowrAnalyzerJupyterFilePlugin } from './file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin';
+/**
+ * The built-in Flowr Analyzer plugins that are always available.
+ */
+export declare const BuiltInPlugins: [["file:description", typeof FlowrAnalyzerDescriptionFilePlugin], ["versions:description", typeof FlowrAnalyzerPackageVersionsDescriptionFilePlugin], ["loading-order:description", typeof FlowrAnalyzerLoadingOrderDescriptionFilePlugin], ["file:rmd", typeof FlowrAnalyzerRmdFilePlugin], ["file:qmd", typeof FlowrAnalyzerQmdFilePlugin], ["file:ipynb", typeof FlowrAnalyzerJupyterFilePlugin]];
+export type BuiltInFlowrPluginName = typeof BuiltInPlugins[number][0];
+export type BuiltInFlowrPluginArgs<N extends BuiltInFlowrPluginName> = N extends typeof BuiltInPlugins[number][0] ? ConstructorParameters<Extract<typeof BuiltInPlugins[number], [N, PluginProducer]>[1]> : never;
+type PluginProducer = new (...args: never[]) => FlowrAnalyzerPlugin;
+/**
+ * Register a new Flowr Analyzer plugin for the registry,
+ * to be used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer}.
+ */
+export declare function registerPluginMaker(plugin: PluginProducer, name?: Exclude<string, BuiltInFlowrPluginName>): void;
+export declare function getPlugin(name: BuiltInFlowrPluginName, args: BuiltInFlowrPluginArgs<typeof name>): FlowrAnalyzerPlugin;
+export declare function getPlugin(name: string, args?: unknown[]): FlowrAnalyzerPlugin | undefined;
+/**
+ * The type used to register a plugin with the {@link FlowrAnalyzerBuilder}.
+ * @see {@link makePlugin}
+ */
+export type PluginToRegister<T extends BuiltInFlowrPluginName | string> = FlowrAnalyzerPlugin | T | string | (T extends BuiltInFlowrPluginName ? [
+    T,
+    BuiltInFlowrPluginArgs<T>
+] : [string, unknown[]]);
+/**
+ * Create a Flowr Analyzer plugin from a {@link PluginToRegister} specification.
+ */
+export declare function makePlugin<T extends BuiltInFlowrPluginName | string>(toRegister: PluginToRegister<T>): FlowrAnalyzerPlugin;
+export {};

package/project/plugins/plugin-registry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInPlugins = void 0;
+exports.registerPluginMaker = registerPluginMaker;
+exports.getPlugin = getPlugin;
+exports.makePlugin = makePlugin;
+const flowr_analyzer_description_file_plugin_1 = require("./file-plugins/flowr-analyzer-description-file-plugin");
+const flowr_analyzer_package_versions_description_file_plugin_1 = require("./package-version-plugins/flowr-analyzer-package-versions-description-file-plugin");
+const flowr_analyzer_loading_order_description_file_plugin_1 = require("./loading-order-plugins/flowr-analyzer-loading-order-description-file-plugin");
+const flowr_analyzer_rmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-rmd-file-plugin");
+const flowr_analyzer_qmd_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-qmd-file-plugin");
+const assert_1 = require("../../util/assert");
+const flowr_analyzer_jupyter_file_plugin_1 = require("./file-plugins/notebooks/flowr-analyzer-jupyter-file-plugin");
+/**
+ * The built-in Flowr Analyzer plugins that are always available.
+ */
+exports.BuiltInPlugins = [
+    ['file:description', flowr_analyzer_description_file_plugin_1.FlowrAnalyzerDescriptionFilePlugin],
+    ['versions:description', flowr_analyzer_package_versions_description_file_plugin_1.FlowrAnalyzerPackageVersionsDescriptionFilePlugin],
+    ['loading-order:description', flowr_analyzer_loading_order_description_file_plugin_1.FlowrAnalyzerLoadingOrderDescriptionFilePlugin],
+    ['file:rmd', flowr_analyzer_rmd_file_plugin_1.FlowrAnalyzerRmdFilePlugin],
+    ['file:qmd', flowr_analyzer_qmd_file_plugin_1.FlowrAnalyzerQmdFilePlugin],
+    ['file:ipynb', flowr_analyzer_jupyter_file_plugin_1.FlowrAnalyzerJupyterFilePlugin],
+];
+/**
+ * The registry of built-in and user-registered Flowr Analyzer plugins.
+ * Used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} to instantiate plugins by name.
+ */
+const PluginRegistry = new Map(exports.BuiltInPlugins);
+/**
+ * Register a new Flowr Analyzer plugin for the registry,
+ * to be used by the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer}.
+ */
+function registerPluginMaker(plugin, name = plugin.name) {
+    PluginRegistry.set(name, plugin);
+}
+/**
+ * Retrieve a registered Flowr Analyzer plugin by its name.
+ * @see {@link PluginToRegister}
+ */
+function getPlugin(name, args) {
+    const plugin = PluginRegistry.get(name);
+    return plugin ? new plugin(...args) : undefined;
+}
+/**
+ * Create a Flowr Analyzer plugin from a {@link PluginToRegister} specification.
+ */
+function makePlugin(toRegister) {
+    if (toRegister instanceof Object && 'process' in toRegister) {
+        return toRegister;
+    }
+    if (Array.isArray(toRegister)) {
+        const [name, args] = toRegister;
+        const plugin = getPlugin(name, args);
+        (0, assert_1.guard)(plugin !== undefined, () => `Unknown Flowr Analyzer plugin: ${name.toString()}`);
+        return plugin;
+    }
+    const plugin = getPlugin(toRegister, []);
+    (0, assert_1.guard)(plugin !== undefined, () => `Unknown Flowr Analyzer plugin: ${toRegister.toString()}`);
+    return plugin;
+}
+//# sourceMappingURL=plugin-registry.js.map

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

@@ -19,6 +19,7 @@ class FlowrAnalyzerProjectDiscoveryPlugin extends flowr_analyzer_plugin_1.FlowrA
     }
 }
 exports.FlowrAnalyzerProjectDiscoveryPlugin = FlowrAnalyzerProjectDiscoveryPlugin;
+const discoverRSourcesRegex = /\.(r|rmd|ipynb|qmd)$/i;
 /**
  * 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).
@@ -27,11 +28,16 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
     name = 'default-project-discovery-plugin';
     description = 'This is the default project discovery plugin that does nothing.';
     version = new semver_1.SemVer('0.0.0');
+    supportedExtensions;
+    constructor(triggerOnExtensions = discoverRSourcesRegex) {
+        super();
+        this.supportedExtensions = triggerOnExtensions;
+    }
     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')) {
+            if (this.supportedExtensions.test(file)) {
                 requests.push({ content: file, request: 'file' });
             }
             else {

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

@@ -9,6 +9,7 @@ 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");
 const cfg_kind_1 = require("../../../project/cfg-kind");
+const extract_cfg_1 = require("../../../control-flow/extract-cfg");
 /* if the node is effected by nse, we have an ingoing nse edge */
 function isQuoted(node, graph) {
     const vertex = graph.ingoingEdges(node);
@@ -191,10 +192,7 @@ async function executeCallContextQueries({ analyzer }, queries) {
         cfg = await analyzer.controlflow([], cfg_kind_1.CfgKind.WithDataflow);
     }
     const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
-    for (const [nodeId, info] of dataflow.graph.vertices(true)) {
-        if (info.tag !== vertex_1.VertexType.FunctionCall) {
-            continue;
-        }
+    for (const [nodeId, info] of dataflow.graph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
         /* if we have a vertex, and we check for aliased calls, we want to know if we define this as desired! */
         if (queriesWhichWantAliases.length > 0) {
             /*
@@ -211,6 +209,7 @@ async function executeCallContextQueries({ analyzer }, queries) {
                 }
             }
         }
+        const calls = cfg ? (0, extract_cfg_1.getCallsInCfg)(cfg, dataflow.graph) : undefined;
         for (const query of promotedQueries.filter(q => !q.includeAliases && (q.callName instanceof RegExp ? q.callName.test(info.name) : q.callName.has(info.name)))) {
             const file = ast.idMap.get(nodeId)?.info.file;
             if (!doesFilepathMatch(file, query.fileFilter)) {
@@ -218,7 +217,7 @@ async function executeCallContextQueries({ analyzer }, queries) {
             }
             let targets = undefined;
             if (query.callTargets) {
-                targets = (0, identify_link_to_last_call_relation_1.satisfiesCallTargets)(nodeId, dataflow.graph, query.callTargets);
+                targets = (0, identify_link_to_last_call_relation_1.satisfiesCallTargets)(info, dataflow.graph, query.callTargets);
                 if (targets === 'no') {
                     continue;
                 }
@@ -235,7 +234,7 @@ async function executeCallContextQueries({ analyzer }, 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, dataflow.graph, link);
+                    const lastCall = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(nodeId, cfg.graph, dataflow.graph, link, calls);
                     if (lastCall) {
                         linkedIds ??= new Set();
                         for (const l of lastCall) {

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -21,7 +21,7 @@ export declare enum CallTargets {
 /**
  * Determines whether the given function call node satisfies the specified call target condition.
  */
-export declare function satisfiesCallTargets(id: NodeId, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
+export declare function satisfiesCallTargets(info: DataflowGraphVertexFunctionCall, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
 /**
  * Gets the value node of the specified argument in the given function call, if it exists and matches the allowed types.
  */
@@ -33,5 +33,8 @@ export declare function getValueOfArgument<Types extends readonly RType[] = read
 }) | undefined;
 /**
  * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
+ * If you pass on `knownCalls` (e.g., produced by {@link getCallsInCfg}), this will only respect the functions
+ * listed there and ignore any other calls. This can be also used to speed up the process if you already have
+ * the known calls available.
  */
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo): NodeId[];
+export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -31,25 +31,22 @@ var CallTargets;
 /**
  * Determines whether the given function call node satisfies the specified call target condition.
  */
-function satisfiesCallTargets(id, graph, callTarget) {
-    const callVertex = graph.getVertex(id, true);
-    if (callVertex === undefined || callVertex.tag !== vertex_1.VertexType.FunctionCall) {
-        return 'no';
-    }
-    const outgoing = graph.outgoingEdges(id);
+function satisfiesCallTargets(info, graph, callTarget) {
+    const outgoing = graph.outgoingEdges(info.id);
     if (outgoing === undefined) {
         return 'no';
     }
-    const callTargets = [...outgoing]
+    const callTargets = outgoing.entries()
         .filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls))
-        .map(([t]) => t);
+        .map(([t]) => t)
+        .toArray();
     let builtIn = false;
-    if (callVertex.environment !== undefined) {
+    if (info.environment !== undefined) {
         /*
          * for performance and scoping reasons, flowR will not identify the global linkage,
          * including any potential built-in mapping.
          */
-        const reResolved = (0, resolve_by_name_1.resolveByName)(callVertex.name, callVertex.environment, identifier_1.ReferenceType.Unknown);
+        const reResolved = (0, resolve_by_name_1.resolveByName)(info.name, info.environment, identifier_1.ReferenceType.Unknown);
         if (reResolved?.some(t => (0, built_in_1.isBuiltIn)(t.definedAt))) {
             builtIn = true;
         }
@@ -115,31 +112,41 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
 }
 /**
  * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
+ * If you pass on `knownCalls` (e.g., produced by {@link getCallsInCfg}), this will only respect the functions
+ * listed there and ignore any other calls. This can be also used to speed up the process if you already have
+ * the known calls available.
  */
-function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
+function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }, knownCalls) {
     if (ignoreIf?.(from, graph)) {
         return [];
     }
     const found = [];
+    const cNameCheck = callName instanceof RegExp ? ({ name }) => callName.test(name)
+        : ({ name }) => callName.has(name);
+    const getVertex = knownCalls ?
+        (node) => knownCalls.get(node) :
+        (node) => {
+            const v = graph.getVertex(node, true);
+            return (0, vertex_1.isFunctionCallVertex)(v) ? v : undefined;
+        };
     (0, simple_visitor_1.visitCfgInReverseOrder)(cfg, [from], node => {
         /* we ignore the start id as it cannot be the last call */
         if (node === from) {
             return;
         }
-        const vertex = graph.getVertex(node, true);
-        if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
+        const vertex = getVertex(node);
+        if (vertex === undefined) {
             return;
         }
-        if (callName instanceof RegExp ? callName.test(vertex.name) : callName.has(vertex.name)) {
+        if (cNameCheck(vertex)) {
             const act = cascadeIf ? cascadeIf(vertex, from, graph) : cascade_action_1.CascadeAction.Stop;
             if (act === cascade_action_1.CascadeAction.Skip) {
                 return;
             }
-            const tar = satisfiesCallTargets(vertex.id, graph, CallTargets.MustIncludeGlobal);
-            if (tar === 'no') {
-                return act === cascade_action_1.CascadeAction.Stop;
+            const tar = satisfiesCallTargets(vertex, graph, CallTargets.MustIncludeGlobal);
+            if (tar !== 'no') {
+                found.push(node);
             }
-            found.push(node);
             return act === cascade_action_1.CascadeAction.Stop;
         }
     });

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

@@ -15,7 +15,7 @@ export interface DataflowClusterQueryResult extends BaseQueryResult {
 }
 export declare const ClusterQueryDefinition: {
     readonly executor: typeof executeDataflowClusterQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/control-flow-query/control-flow-query-format.d.ts

@@ -22,7 +22,7 @@ export interface ControlFlowQueryResult extends BaseQueryResult {
 }
 export declare const ControlFlowQueryDefinition: {
     readonly executor: typeof executeControlFlowQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/control-flow-query/control-flow-query-format.js

@@ -26,9 +26,10 @@ exports.ControlFlowQueryDefinition = {
     }).description('The control flow query provides the control flow graph of the analysis, optionally simplified.'),
     flattenInvolvedNodes: (queryResults) => {
         const out = queryResults;
-        return [...out.controlFlow.graph.vertices(true)]
+        return out.controlFlow.graph.vertices(true).entries()
             .filter(([, v]) => v.type !== control_flow_graph_1.CfgVertexType.Block)
-            .map(v => v[0]);
+            .map(v => v[0])
+            .toArray();
     }
 };
 //# sourceMappingURL=control-flow-query-format.js.map

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-executor.js

@@ -20,7 +20,7 @@ async function executeDataflowLensQuery({ analyzer }, queries) {
             nameRegex: '<-|<<-|->|->>|=|+|-|*|/|\\|>|function|repeat|if|next|break',
             blacklistWithName: true
         }
-    });
+    }, analyzer.inspectContext().env.makeCleanEnv());
     const timing = Date.now() - now;
     return {
         '.meta': {

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-format.d.ts

@@ -14,7 +14,7 @@ export interface DataflowLensQueryResult extends BaseQueryResult {
 }
 export declare const DataflowLensQueryDefinition: {
     readonly executor: typeof executeDataflowLensQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/dataflow-query/dataflow-query-format.d.ts

@@ -15,7 +15,7 @@ export interface DataflowQueryResult extends BaseQueryResult {
 }
 export declare const DataflowQueryDefinition: {
     readonly executor: typeof executeDataflowQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -1,6 +1,6 @@
 import { type DependenciesQuery, type DependenciesQueryResult } from './dependencies-query-format';
 import type { BasicQueryData } from '../../base-query-format';
 /**
- *
+ * Executes a dependencies query.
  */
 export declare function executeDependenciesQuery({ analyzer, }: BasicQueryData, queries: readonly DependenciesQuery[]): Promise<DependenciesQueryResult>;

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

@@ -12,7 +12,7 @@ const identify_link_to_last_call_relation_1 = require("../call-context-query/ide
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 const assert_1 = require("../../../util/assert");
 /**
- *
+ * Executes a dependencies query.
  */
 async function executeDependenciesQuery({ analyzer, }, queries) {
     if (queries.length !== 1) {
@@ -76,8 +76,8 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
         const vertex = dataflow.graph.getVertex(id);
         const info = functionMap.get(name);
-        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
-        const linkedArgs = collectValuesFromLinks(args, { dataflow, config }, linkedIds);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
+        const linkedArgs = collectValuesFromLinks(args, { dataflow, config, ctx: data.analyzer.inspectContext() }, linkedIds);
         const linked = dropInfoOnLinkedIds(linkedIds);
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
@@ -97,7 +97,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
             (0, assert_1.guard)('mode' in (info.additionalArgs ?? {}), 'Need additional argument mode when checking for mode');
             const margs = info.additionalArgs?.mode;
             (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
-            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
+            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
             const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
             if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
                 // all modes are read-only, so we can ignore this
@@ -159,7 +159,7 @@ function collectValuesFromLinks(args, data, linkedIds) {
         if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
             continue;
         }
-        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.ctx);
         if (args === undefined) {
             continue;
         }

package/queries/catalog/dependencies-query/dependencies-query-format.d.ts

@@ -70,7 +70,7 @@ export interface DependencyInfo extends Record<string, unknown> {
 export declare function getAllCategories(queries: readonly DependenciesQuery[]): Record<DependencyCategoryName, DependencyCategorySettings>;
 export declare const DependenciesQueryDefinition: {
     readonly executor: typeof executeDependenciesQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[], queries: readonly import("../../query").Query[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[], queries: readonly import("../../query").Query[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly import("../../query").Query[]) => NodeId[];
 };

package/queries/catalog/dependencies-query/dependencies-query-format.js

@@ -25,7 +25,7 @@ exports.DefaultDependencyCategories = {
         /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
         additionalAnalysis: async (data, ignoreDefault, _functions, _queryResults, result) => {
             if (!ignoreDefault) {
-                (0, visitor_1.visitAst)((await data.analyzer.normalize()).ast, n => {
+                (0, visitor_1.visitAst)((await data.analyzer.normalize()).ast.files.map(f => f.root), n => {
                     if (n.type === type_1.RType.Symbol && n.namespace) {
                         const dep = data.analyzer.inspectContext().deps.getDependency(n.namespace);
                         /* we should improve the identification of ':::' */

package/queries/catalog/df-shape-query/df-shape-query-executor.d.ts

@@ -1,6 +1,6 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { DfShapeQuery, DfShapeQueryResult } from './df-shape-query-format';
 /**
- * Executes the given dataframe shape queries using the provided analyzer.
+ * Executes the given data frame shape queries using the provided analyzer.
  */
 export declare function executeDfShapeQuery({ analyzer }: BasicQueryData, queries: readonly DfShapeQuery[]): Promise<DfShapeQueryResult>;