@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -1,5 +1,8 @@
 import type { CallContextQuery, CallContextQueryResult, CallNameTypes, LinkTo } from './call-context-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ *
+ */
 export declare function promoteCallName(callName: CallNameTypes, exact?: boolean): RegExp | Set<string>;
 export type PromotedLinkTo = Omit<LinkTo, 'callName'> & {
     callName: RegExp | Set<string>;

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);
@@ -43,6 +44,9 @@ function isSubCallQuery(query) {
 function exactCallNameRegex(name) {
     return new RegExp(`^(${name})$`);
 }
+/**
+ *
+ */
 function promoteCallName(callName, exact = false) {
     return Array.isArray(callName) ? new Set(callName) : exact ? exactCallNameRegex(callName) : new RegExp(callName);
 }
@@ -208,6 +212,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)) {
@@ -215,7 +220,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;
                 }
@@ -232,7 +237,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/call-context-query-format.d.ts

@@ -1,14 +1,14 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { executeCallContextQueries } from './call-context-query-executor';
-import type { OutputFormatter } from '../../../util/text/ansi';
+import { type OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
 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';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 export interface FileFilter<FilterType> {
     /**
      * Regex that a node's file attribute must match to be considered
@@ -108,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, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -1,6 +1,6 @@
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataflowGraph } from '../../../dataflow/graph/graph';
-import type { DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
+import { type DataflowGraph } from '../../../dataflow/graph/graph';
+import { type DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
 import { RType } from '../../../r-bridge/lang-4.x/ast/model/type';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LinkTo } from './call-context-query-format';
@@ -18,11 +18,23 @@ export declare enum CallTargets {
     /** call targets a function that is defined locally or globally */
     Any = "any"
 }
-export declare function satisfiesCallTargets(id: NodeId, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
+/**
+ * Determines whether the given function call node satisfies the specified call target condition.
+ */
+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.
+ */
 export declare function getValueOfArgument<Types extends readonly RType[] = readonly RType[]>(graph: DataflowGraph, call: DataflowGraphVertexFunctionCall | undefined, argument: {
     name?: string;
     index: number;
 }, additionalAllowedTypes?: Types): (RNodeWithParent & {
     type: Types[number];
 }) | undefined;
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo): NodeId[];
+/**
+ * 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, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): NodeId[];

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

@@ -28,25 +28,25 @@ var CallTargets;
     /** call targets a function that is defined locally or globally */
     CallTargets["Any"] = "any";
 })(CallTargets || (exports.CallTargets = CallTargets = {}));
-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);
+/**
+ * Determines whether the given function call node satisfies the specified call target condition.
+ */
+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;
         }
@@ -82,6 +82,9 @@ function satisfiesCallTargets(id, graph, callTarget) {
             (0, assert_1.assertUnreachable)(callTarget);
     }
 }
+/**
+ * Gets the value node of the specified argument in the given function call, if it exists and matches the allowed types.
+ */
 function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
     if (!call) {
         return undefined;
@@ -107,30 +110,43 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
         return !additionalAllowedTypes || additionalAllowedTypes.includes(valueNode.type) ? valueNode : undefined;
     }
 }
-function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
+/**
+ * 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 }, 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-executor.d.ts

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

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDataflowClusterQuery = executeDataflowClusterQuery;
 const log_1 = require("../../../util/log");
 const cluster_1 = require("../../../dataflow/cluster");
+/**
+ * Executes the given dataflow cluster queries using the provided analyzer.
+ */
 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);

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").FlowrAnalysisProvider, 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/config-query/config-query-executor.d.ts

@@ -1,3 +1,6 @@
 import type { ConfigQuery, ConfigQueryResult } from './config-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Executes the given configuration queries using the provided analyzer.
+ */
 export declare function executeConfigQuery({ analyzer }: BasicQueryData, queries: readonly ConfigQuery[]): Promise<ConfigQueryResult>;

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

@@ -4,6 +4,9 @@ exports.executeConfigQuery = executeConfigQuery;
 const log_1 = require("../../../util/log");
 const assert_1 = require("../../../util/assert");
 const objects_1 = require("../../../util/objects");
+/**
+ * Executes the given configuration queries using the provided analyzer.
+ */
 function executeConfigQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Config query usually expects only up to one query, but got', queries.length);

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

@@ -4,6 +4,9 @@ import { type OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
 import type { FlowrConfigOptions } from '../../../config';
 import type { DeepPartial } from 'ts-essentials';
+import type { ParsedQueryLine } from '../../query';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { CommandCompletions } from '../../../cli/repl/core';
 export interface ConfigQuery extends BaseQueryFormat {
     readonly type: 'config';
     readonly update?: DeepPartial<FlowrConfigOptions>;
@@ -11,8 +14,8 @@ export interface ConfigQuery extends BaseQueryFormat {
 export interface ConfigQueryResult extends BaseQueryResult {
     readonly config: FlowrConfigOptions;
 }
-declare function configReplCompleter(partialLine: readonly string[], config: FlowrConfigOptions): string[];
-declare function configQueryLineParser(line: readonly string[], _config: FlowrConfigOptions): [ConfigQuery];
+declare function configReplCompleter(partialLine: readonly string[], _startingNewArg: boolean, config: FlowrConfigOptions): CommandCompletions;
+declare function configQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'config'>;
 export declare const ConfigQueryDefinition: {
     readonly executor: typeof executeConfigQuery;
     readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;

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

@@ -9,17 +9,17 @@ const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const json_1 = require("../../../util/json");
-function configReplCompleter(partialLine, config) {
+function configReplCompleter(partialLine, _startingNewArg, config) {
     if (partialLine.length === 0) {
         // update specific fields
-        return ['+'];
+        return { completions: ['+'] };
     }
     else if (partialLine.length === 1 && partialLine[0].startsWith('+')) {
         const path = partialLine[0].slice(1).split('.').filter(p => p.length > 0);
         const fullPath = path.slice();
         const lastPath = partialLine[0].endsWith('.') ? '' : path.pop() ?? '';
         if (lastPath.endsWith('=')) {
-            return [];
+            return { completions: [] };
         }
         const subConfig = path.reduce((obj, key) => (obj && obj[key] !== undefined && typeof obj[key] === 'object') ? obj[key] : obj, config);
         if (subConfig && !(subConfig[lastPath] !== undefined && typeof subConfig[lastPath] !== 'object')) {
@@ -27,23 +27,23 @@ function configReplCompleter(partialLine, config) {
                 .filter(k => k.startsWith(lastPath) && k !== lastPath)
                 .map(k => `${partialLine[0].slice(0, 1)}${[...path, k].join('.')}`);
             if (have.length > 0) {
-                return have;
+                return { completions: have };
             }
             else if (lastPath.length > 0) {
-                return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}.`];
+                return { completions: [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}.`] };
             }
         }
-        return [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}=`];
+        return { completions: [`${partialLine[0].slice(0, 1)}${fullPath.join('.')}=`] };
     }
-    return [];
+    return { completions: [] };
 }
-function configQueryLineParser(line, _config) {
+function configQueryLineParser(output, line, _config) {
     if (line.length > 0 && line[0].startsWith('+')) {
         const [pathPart, ...valueParts] = line[0].slice(1).split('=');
         // build the update object
         const path = pathPart.split('.').filter(p => p.length > 0);
         if (path.length === 0 || valueParts.length !== 1) {
-            console.error('Invalid config update syntax, must be of the form +path.to.field=value');
+            output.stdout(`Invalid config update syntax, must be of the form ${(0, ansi_1.bold)('+path.to.field=value', output.formatter)}`);
         }
         else {
             const update = {};
@@ -67,15 +67,12 @@ function configQueryLineParser(line, _config) {
                     current = current[key];
                 }
             }
-            return [{
-                    type: 'config',
-                    update
-                }];
+            return { query: [{ type: 'config', update }]
+            };
         }
     }
-    return [{
-            type: 'config'
-        }];
+    return { query: [{ type: 'config' }]
+    };
 }
 exports.ConfigQueryDefinition = {
     executor: config_query_executor_1.executeConfigQuery,

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

@@ -1,3 +1,6 @@
 import type { ControlFlowQuery, ControlFlowQueryResult } from './control-flow-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ *
+ */
 export declare function executeControlFlowQuery({ analyzer }: BasicQueryData, queries: readonly ControlFlowQuery[]): Promise<ControlFlowQueryResult>;

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeControlFlowQuery = executeControlFlowQuery;
 const log_1 = require("../../../util/log");
 const cfg_kind_1 = require("../../../project/cfg-kind");
+/**
+ *
+ */
 async function executeControlFlowQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('The control flow query expects only up to one query, but got', queries.length);

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

@@ -2,8 +2,8 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import { executeControlFlowQuery } from './control-flow-query-executor';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { ControlFlowInformation } from '../../../control-flow/control-flow-graph';
-import type { CfgSimplificationPassName } from '../../../control-flow/cfg-simplification';
+import { type ControlFlowInformation } from '../../../control-flow/control-flow-graph';
+import { type CfgSimplificationPassName } from '../../../control-flow/cfg-simplification';
 /**
  * Provides the control flow graph with an optional, fixed configuration
  */
@@ -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").FlowrAnalysisProvider, 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/dataflow-lens-query/dataflow-lens-query-executor.d.ts

@@ -1,3 +1,6 @@
 import type { DataflowLensQuery, DataflowLensQueryResult } from './dataflow-lens-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Executes the given dataflow lens queries using the provided analyzer.
+ */
 export declare function executeDataflowLensQuery({ analyzer }: BasicQueryData, queries: readonly DataflowLensQuery[]): Promise<DataflowLensQueryResult>;

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

@@ -4,6 +4,9 @@ exports.executeDataflowLensQuery = executeDataflowLensQuery;
 const log_1 = require("../../../util/log");
 const dfg_view_1 = require("../../../util/simple-df/dfg-view");
 const vertex_1 = require("../../../dataflow/graph/vertex");
+/**
+ * Executes the given dataflow lens queries using the provided analyzer.
+ */
 async function executeDataflowLensQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Dataflow query expects only up to one query, but got', queries.length);

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").FlowrAnalysisProvider, 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-executor.d.ts

@@ -1,3 +1,6 @@
 import type { DataflowQuery, DataflowQueryResult } from './dataflow-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Executes the given dataflow queries.
+ */
 export declare function executeDataflowQuery({ analyzer }: BasicQueryData, queries: readonly DataflowQuery[]): Promise<DataflowQueryResult>;

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDataflowQuery = executeDataflowQuery;
 const log_1 = require("../../../util/log");
+/**
+ * Executes the given dataflow queries.
+ */
 async function executeDataflowQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Dataflow query expects only up to one query, but got', queries.length);

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").FlowrAnalysisProvider, 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,3 +1,6 @@
-import type { DependenciesQuery, DependenciesQueryResult } from './dependencies-query-format';
+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

@@ -11,6 +11,9 @@ const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 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) {
         log_1.log.warn('Dependencies query expects only up to one query, but got ', queries.length, 'only using the first query');
@@ -33,12 +36,12 @@ async function executeDependenciesQuery({ analyzer, }, queries) {
     }
     const queryResults = functions.values().toArray().flat().length === 0 ? { kinds: {}, '.meta': { timing: 0 } } :
         await (0, query_1.executeQueriesOfSameType)(data, functions.entries().map(([c, f]) => makeCallContextQuery(f, c)).toArray().flat());
-    const results = Object.fromEntries(functions.entries().map(([c, f]) => {
+    const results = Object.fromEntries(await Promise.all(functions.entries().map(async ([c, f]) => {
         const results = getResults(queries, { dataflow, config, normalize }, queryResults, c, f, data);
         // only default categories allow additional analyses, so we null-coalesce here!
-        dependencies_query_format_1.DefaultDependencyCategories[c]?.additionalAnalysis?.(data, ignoreDefault, f, queryResults, results);
+        await dependencies_query_format_1.DefaultDependencyCategories[c]?.additionalAnalysis?.(data, ignoreDefault, f, queryResults, results);
         return [c, results];
-    }));
+    })));
     return {
         '.meta': {
             timing: Date.now() - now
@@ -108,7 +111,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {
-                const dep = value ? data?.analyzer.context().deps.getDependency(value) ?? undefined : undefined;
+                const dep = value ? data?.analyzer.inspectContext().deps.getDependency(value) ?? undefined : undefined;
                 const result = (0, objects_1.compactRecord)({
                     nodeId: id,
                     functionName: vertex.name,

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

@@ -64,10 +64,13 @@ export interface DependencyInfo extends Record<string, unknown> {
     versionConstraints?: Range[];
     derivedVersion?: Range;
 }
+/**
+ * Gets all dependency categories, including user-defined additional categories.
+ */
 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").FlowrAnalysisProvider, 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,9 +25,9 @@ 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.context().deps.getDependency(n.namespace);
+                        const dep = data.analyzer.inspectContext().deps.getDependency(n.namespace);
                         /* we should improve the identification of ':::' */
                         result.push({
                             nodeId: n.info.id,
@@ -81,6 +81,9 @@ function printResultSection(title, infos, result) {
         result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}${i.value !== undefined ? `, \`${i.value}\`` : ''}${i.derivedVersion !== undefined ? `, Version: \`${i.derivedVersion.format()}\`` : ''}`).join('\n'));
     }
 }
+/**
+ * Gets all dependency categories, including user-defined additional categories.
+ */
 function getAllCategories(queries) {
     let categories = exports.DefaultDependencyCategories;
     for (const query of queries) {

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

@@ -1,3 +1,6 @@
-import type { DfShapeQuery, DfShapeQueryResult } from './df-shape-query-format';
 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.
+ */
 export declare function executeDfShapeQuery({ analyzer }: BasicQueryData, queries: readonly DfShapeQuery[]): Promise<DfShapeQueryResult>;

package/queries/catalog/df-shape-query/df-shape-query-executor.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDfShapeQuery = executeDfShapeQuery;
-const log_1 = require("../../../util/log");
 const shape_inference_1 = require("../../../abstract-interpretation/data-frame/shape-inference");
 const parse_1 = require("../../../slicing/criterion/parse");
+const log_1 = require("../../../util/log");
+/**
+ * Executes the given dataframe shape queries using the provided analyzer.
+ */
 async function executeDfShapeQuery({ analyzer }, queries) {
     if (queries.length !== 1 && queries.some(query => query.criterion === undefined)) {
         log_1.log.warn('The dataframe shape query expects only up to one query without slicing criterion, but got', queries.length);
         queries = [{ type: 'df-shape' }];
     }
-    const graph = (await analyzer.dataflow()).graph;
     const ast = await analyzer.normalize();
+    const dfg = (await analyzer.dataflow()).graph;
+    const cfg = await analyzer.controlflow();
     const start = Date.now();
-    const domains = (0, shape_inference_1.inferDataFrameShapes)(await analyzer.controlflow(), graph, ast, analyzer.flowrConfig);
+    const domains = (0, shape_inference_1.inferDataFrameShapes)(cfg, dfg, ast, analyzer.inspectContext());
     if (queries.length === 1 && queries[0].criterion === undefined) {
         return {
             '.meta': {
@@ -33,7 +37,7 @@ async function executeDfShapeQuery({ analyzer }, queries) {
         }
         const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
         const node = ast.idMap.get(nodeId);
-        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node?.info.id, graph);
+        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node?.info.id, dfg);
         result.set(query.criterion, value);
     }
     return {

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

@@ -1,8 +1,11 @@
+import { type DataFrameDomain, DataFrameStateDomain } from '../../../abstract-interpretation/data-frame/dataframe-domain';
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
-import Joi from 'joi';
-import type { DataFrameDomain, DataFrameStateDomain } from '../../../abstract-interpretation/data-frame/domain';
+import type { ParsedQueryLine } from '../../query';
 import { executeDfShapeQuery } from './df-shape-query-executor';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
+import Joi from 'joi';
 /** Infer the shape of data frames using abstract interpretation. */
 export interface DfShapeQuery extends BaseQueryFormat {
     readonly type: 'df-shape';
@@ -11,9 +14,13 @@ export interface DfShapeQuery extends BaseQueryFormat {
 export interface DfShapeQueryResult extends BaseQueryResult {
     domains: DataFrameStateDomain | Map<SingleSlicingCriterion, DataFrameDomain | undefined>;
 }
+declare function dfShapeQueryLineParser(_output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'df-shape'>;
 export declare const DfShapeQueryDefinition: {
     readonly executor: typeof executeDfShapeQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").FlowrAnalysisProvider, 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 jsonFormatter: (queryResults: BaseQueryResult) => object;
+    readonly fromLine: typeof dfShapeQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };
+export {};