@eagleoutice/flowr 2.6.0 → 2.6.2

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

@@ -49,6 +49,7 @@ export declare class FlowrAnalyzerLoadingOrderContext extends AbstractFlowrAnaly
     private guesses;
     /** just the base collection of requests we know nothing about the order! */
     private unordered;
+    reset(): void;
     /**
      * Add one or multiple requests to the context.
      * These are considered unordered (i.e., ordered implicitly by the order of addition) until a plugin provides either a guess or a known order.

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

@@ -23,6 +23,12 @@ class FlowrAnalyzerLoadingOrderContext extends abstract_flowr_analyzer_context_1
     guesses = [];
     /** just the base collection of requests we know nothing about the order! */
     unordered = [];
+    reset() {
+        this.knownOrder = undefined;
+        this.guesses.length = 0;
+        this.unordered.length = 0;
+        this.rerunRequired = this.plugins.length > 0;
+    }
     /**
      * Add one or multiple requests to the context.
      * These are considered unordered (i.e., ordered implicitly by the order of addition) until a plugin provides either a guess or a known order.

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

@@ -28,7 +28,6 @@ export declare enum SpecialFileRole {
  *
  * See {@link FlowrFile} for a basic single-cache implementation and {@link FlowrTextFile} for a text-file specific implementation.
  * If you want to pass in inline text files, see {@link FlowrInlineTextFile}.
- *
  * @typeParam Content - The type of the content returned by the `content()` method.
  */
 export interface FlowrFileProvider<Content = unknown> {

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

@@ -1,4 +1,4 @@
-import type { EngineConfig, FlowrConfigOptions } from '../config';
+import { type EngineConfig, type FlowrConfigOptions } from '../config';
 import type { DeepWritable } from 'ts-essentials';
 import { fileProtocol, requestFromInput } from '../r-bridge/retriever';
 import { FlowrAnalyzer } from './flowr-analyzer';
@@ -11,7 +11,6 @@ import type { RAnalysisRequest } from './context/flowr-analyzer-files-context';
  * with {@link FlowrAnalyzerBuilder#build|`.build()`} or {@link FlowrAnalyzerBuilder#buildSync|`.buildSync()`}.
  *
  * You can add new files and folders to analyze using the constructor or the {@link FlowrAnalyzerBuilder#add|`.add()`} method.
- *
  * @example Let's create an analyzer for a single R script file:
  *
  * ```ts
@@ -83,7 +82,6 @@ export declare class FlowrAnalyzerBuilder {
     setInput(input: Omit<NormalizeRequiredInput, 'request'>): this;
     /**
      * Register one or multiple additional plugins.
-     *
      * @see {@link FlowrAnalyzerBuilder#unregisterPlugins} to remove plugins.
      */
     registerPlugins(...plugin: readonly FlowrAnalyzerPlugin[]): this;

package/project/flowr-analyzer-builder.js

@@ -14,7 +14,6 @@ const flowr_analyzer_cache_1 = require("./cache/flowr-analyzer-cache");
  * with {@link FlowrAnalyzerBuilder#build|`.build()`} or {@link FlowrAnalyzerBuilder#buildSync|`.buildSync()`}.
  *
  * You can add new files and folders to analyze using the constructor or the {@link FlowrAnalyzerBuilder#add|`.add()`} method.
- *
  * @example Let's create an analyzer for a single R script file:
  *
  * ```ts
@@ -133,7 +132,6 @@ class FlowrAnalyzerBuilder {
     }
     /**
      * Register one or multiple additional plugins.
-     *
      * @see {@link FlowrAnalyzerBuilder#unregisterPlugins} to remove plugins.
      */
     registerPlugins(...plugin) {
@@ -181,16 +179,17 @@ class FlowrAnalyzerBuilder {
         (0, assert_1.guard)(this.parser !== undefined, 'No parser set, please use the setParser or setEngine method to set a parser before building the analyzer');
         (0, assert_1.guard)(this.request !== undefined, 'Currently we require at least one request to build an analyzer, please provide one using the constructor or the addRequest method');
         const context = new flowr_analyzer_context_1.FlowrAnalyzerContext(this.plugins);
-        context.addRequests(this.request);
-        // we do it here to save time later if the analyzer is to be duplicated
-        context.resolvePreAnalysis();
         const cache = flowr_analyzer_cache_1.FlowrAnalyzerCache.create({
             parser: this.parser,
             config: this.flowrConfig,
             request: context.files.computeLoadingOrder(),
             ...(this.input ?? {})
         });
-        return new flowr_analyzer_1.FlowrAnalyzer(this.flowrConfig, this.parser, context, cache);
+        const analyzer = new flowr_analyzer_1.FlowrAnalyzer(this.flowrConfig, this.parser, context, cache);
+        analyzer.addRequests(this.request);
+        // we do it here to save time later if the analyzer is to be duplicated
+        context.resolvePreAnalysis();
+        return analyzer;
     }
 }
 exports.FlowrAnalyzerBuilder = FlowrAnalyzerBuilder;

package/project/flowr-analyzer.d.ts

@@ -1,30 +1,50 @@
 import type { FlowrConfigOptions } from '../config';
-import type { KnownParser, KnownParserName, ParseStepOutput } from '../r-bridge/parser';
-import type { Queries, QueryResults, SupportedQueryTypes } from '../queries/query';
+import type { KnownParser, KnownParserInformation, ParseStepOutput } from '../r-bridge/parser';
+import { type Queries, type QueryResults, type SupportedQueryTypes } from '../queries/query';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
 import type { CfgSimplificationPassName } from '../control-flow/cfg-simplification';
 import type { PipelinePerStepMetaInformation } from '../core/steps/pipeline/pipeline';
-import type { FlowrAnalyzerCache } from './cache/flowr-analyzer-cache';
+import type { AnalyzerCacheType, FlowrAnalyzerCache } from './cache/flowr-analyzer-cache';
 import type { FlowrSearchLike, SearchOutput } from '../search/flowr-search-builder';
-import type { GetSearchElements } from '../search/flowr-search-executor';
+import { type GetSearchElements } from '../search/flowr-search-executor';
 import type { FlowrAnalyzerContext, ReadOnlyFlowrAnalyzerContext } from './context/flowr-analyzer-context';
+import { CfgKind } from './cfg-kind';
+import type { RAnalysisRequest } from './context/flowr-analyzer-files-context';
 /**
- * Exposes the central analyses and information provided by the {@link FlowrAnalyzer} to the linter, search, and query APIs.
- * This allows us to exchange the underlying implementation of the analyzer without affecting the APIs.
+ * Extends the {@link ReadonlyFlowrAnalysisProvider} with methods that allow modifying the analyzer state.
  */
-export interface FlowrAnalysisProvider {
-    /**
-     * Get the name of the parser used by the analyzer.
-     */
-    parserName(): string;
+export interface FlowrAnalysisProvider extends ReadonlyFlowrAnalysisProvider {
     /**
      * Returns project context information.
      * If you are a user that wants to inspect the context, prefer {@link inspectContext} instead.
      * Please be aware that modifications to the context may break analyzer assumptions.
      */
     context(): FlowrAnalyzerContext;
+    /**
+     * Add multiple analysis requests to the analyzer instance
+     */
+    addRequests(requests: readonly RAnalysisRequest[]): void;
+    /**
+     * Add a single analysis request to the analyzer instance
+     */
+    addRequest(request: RAnalysisRequest): void;
+    /**
+     * Reset the analyzer state, including the context and the cache.
+     */
+    reset(): void;
+}
+/**
+ * Exposes the central analyses and information provided by the {@link FlowrAnalyzer} to the linter, search, and query APIs.
+ * This allows us to exchange the underlying implementation of the analyzer without affecting the APIs.
+ */
+export interface ReadonlyFlowrAnalysisProvider {
+    /**
+     * Returns a set of additional data and helper functions exposed by the underlying {@link KnownParser},
+     * including the parser's {@link BaseParserInformation.name} and corresponding version information.
+     */
+    parserInformation(): KnownParserInformation;
     /**
      * Returns a read-only version of the project context information.
      * This is the preferred method for users that want to inspect the context.
@@ -50,17 +70,10 @@ export interface FlowrAnalysisProvider {
     /**
      * Get the control flow graph (CFG) for the request.
      * @param simplifications - Simplification passes to be applied to the CFG.
-     * @param useDataflow     - Whether to use the dataflow graph for the creation of the CFG.
+     * @param kind            - The kind of CFG that is requested. By default, the CFG without dataflow information is returned.
      * @param force           - Do not use the cache, instead force new analyses.
      */
-    controlflow(simplifications?: readonly CfgSimplificationPassName[], useDataflow?: boolean, force?: boolean): Promise<ControlFlowInformation>;
-    /**
-     * Get a quick and dirty control flow graph (CFG) for the request.
-     * This does not use the dataflow information and does not apply any simplifications.
-     *
-     * @param force - Do not use the cache, instead force new analyses.
-     */
-    controlflowQuick(force?: boolean): Promise<ControlFlowInformation>;
+    controlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind, force?: boolean): Promise<ControlFlowInformation>;
     /**
      * Access the query API for the request.
      * @param query - The list of queries.
@@ -74,10 +87,6 @@ export interface FlowrAnalysisProvider {
      * This executes all steps of the core analysis (parse, normalize, dataflow).
      */
     runFull(force?: boolean): Promise<void>;
-    /**
-     * Reset all caches used by the analyzer and effectively force all analyses to be redone.
-     */
-    reset(): void;
     /** This is the config used for the analyzer */
     flowrConfig: FlowrConfigOptions;
 }
@@ -89,17 +98,17 @@ export interface FlowrAnalysisProvider {
  *
  * To inspect the context of the analyzer, use {@link FlowrAnalyzer#inspectContext} (if you are a plugin and need to modify it, use {@link FlowrAnalyzer#context} instead).
  */
-export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> implements FlowrAnalysisProvider {
+export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> implements ReadonlyFlowrAnalysisProvider {
     readonly flowrConfig: FlowrConfigOptions;
     /** The parser and engine backend */
     private readonly parser;
     /** The cache used for storing analysis results */
     private readonly cache;
     private readonly ctx;
+    private parserInfo;
     /**
      * Create a new analyzer instance.
      * **Prefer the use of the {@link FlowrAnalyzerBuilder} instead of calling this constructor directly.**
-     *
      * @param config - The FlowR config to use for the analyses
      * @param parser - The parser to use for parsing the given request.
      * @param ctx    - The context to use for the analyses.
@@ -107,15 +116,16 @@ export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> imp
      */
     constructor(config: FlowrConfigOptions, parser: Parser, ctx: FlowrAnalyzerContext, cache: FlowrAnalyzerCache<Parser>);
     context(): FlowrAnalyzerContext;
+    parserInformation(): KnownParserInformation;
     inspectContext(): ReadOnlyFlowrAnalyzerContext;
     reset(): void;
-    parserName(): KnownParserName;
-    parse(force?: boolean): ReturnType<typeof this.cache.parse>;
-    normalize(force?: boolean): ReturnType<typeof this.cache.normalize>;
-    dataflow(force?: boolean): ReturnType<typeof this.cache.dataflow>;
+    addRequests(requests: readonly RAnalysisRequest[]): void;
+    addRequest(request: RAnalysisRequest): void;
+    parse(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['parse']>>;
+    normalize(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['normalize']>>;
+    dataflow(force?: boolean): Promise<NonNullable<AnalyzerCacheType<Parser>['dataflow']>>;
     runFull(force?: boolean): Promise<void>;
-    controlflow(simplifications?: readonly CfgSimplificationPassName[], useDataflow?: boolean, force?: boolean): Promise<ControlFlowInformation>;
-    controlflowQuick(force?: boolean): Promise<ControlFlowInformation>;
+    controlflow(simplifications?: readonly CfgSimplificationPassName[], kind?: CfgKind, force?: boolean): Promise<ControlFlowInformation>;
     query<Types extends SupportedQueryTypes = SupportedQueryTypes>(query: Queries<Types>): Promise<QueryResults<Types>>;
     runSearch<Search extends FlowrSearchLike>(search: Search): Promise<GetSearchElements<SearchOutput<Search>>>;
     /**

package/project/flowr-analyzer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrAnalyzer = void 0;
 const query_1 = require("../queries/query");
 const flowr_search_executor_1 = require("../search/flowr-search-executor");
+const cfg_kind_1 = require("./cfg-kind");
 /**
  * Central class for conducting analyses with FlowR.
  * Use the {@link FlowrAnalyzerBuilder} to create a new instance.
@@ -18,10 +19,10 @@ class FlowrAnalyzer {
     /** The cache used for storing analysis results */
     cache;
     ctx;
+    parserInfo;
     /**
      * Create a new analyzer instance.
      * **Prefer the use of the {@link FlowrAnalyzerBuilder} instead of calling this constructor directly.**
-     *
      * @param config - The FlowR config to use for the analyses
      * @param parser - The parser to use for parsing the given request.
      * @param ctx    - The context to use for the analyses.
@@ -36,14 +37,22 @@ class FlowrAnalyzer {
     context() {
         return this.ctx;
     }
+    parserInformation() {
+        this.parserInfo ??= this.parser.information(this);
+        return this.parserInfo;
+    }
     inspectContext() {
         return this.ctx.inspect();
     }
     reset() {
+        this.ctx.reset();
         this.cache.reset();
     }
-    parserName() {
-        return this.parser.name;
+    addRequests(requests) {
+        this.ctx.addRequests(requests);
+    }
+    addRequest(request) {
+        this.ctx.addRequest(request);
     }
     async parse(force) {
         return this.cache.parse(force);
@@ -58,11 +67,8 @@ class FlowrAnalyzer {
         await this.dataflow(force);
         return;
     }
-    async controlflow(simplifications, useDataflow, force) {
-        return this.cache.controlflow(force, useDataflow ?? false, simplifications);
-    }
-    async controlflowQuick(force) {
-        return this.controlflow(undefined, false, force);
+    async controlflow(simplifications, kind, force) {
+        return this.cache.controlflow(force, kind ?? cfg_kind_1.CfgKind.NoDataflow, simplifications);
     }
     async query(query) {
         return (0, query_1.executeQueries)({ analyzer: this }, query);

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

@@ -3,7 +3,7 @@ import { SemVer } from 'semver';
 import type { PathLike } from 'fs';
 import type { FlowrAnalyzerContext } from '../../context/flowr-analyzer-context';
 import { FlowrDescriptionFile } from './flowr-description-file';
-import type { FlowrFileProvider } from '../../context/flowr-file';
+import { type FlowrFileProvider } from '../../context/flowr-file';
 export declare const descriptionFileLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This plugin provides support for R `DESCRIPTION` files.

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

@@ -1,5 +1,4 @@
-import type { FlowrFileProvider, SpecialFileRole } from '../../context/flowr-file';
-import { FlowrFile } from '../../context/flowr-file';
+import { type FlowrFileProvider, type SpecialFileRole, FlowrFile } from '../../context/flowr-file';
 export type DCF = Map<string, string[]>;
 /**
  * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
@@ -13,7 +12,6 @@ export declare class FlowrDescriptionFile extends FlowrFile<DCF> {
     constructor(file: FlowrFileProvider<string>);
     /**
      * Loads and parses the content of the wrapped file as a DCF structure.
-     *
      * @see {@link parseDCF} for details on the parsing logic.
      */
     protected loadContent(): DCF;

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

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

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

@@ -1,7 +1,7 @@
 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';
+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.

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

@@ -1,4 +1,4 @@
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -11,5 +11,5 @@ export interface BaseQueryResult {
     readonly '.meta': BaseQueryMeta;
 }
 export interface BasicQueryData {
-    readonly analyzer: FlowrAnalysisProvider;
+    readonly analyzer: ReadonlyFlowrAnalysisProvider;
 }

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

@@ -8,6 +8,7 @@ const edge_1 = require("../../../dataflow/graph/edge");
 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");
 /* if the node is effected by nse, we have an ingoing nse edge */
 function isQuoted(node, graph) {
     const vertex = graph.ingoingEdges(node);
@@ -42,6 +43,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);
 }
@@ -184,7 +188,7 @@ async function executeCallContextQueries({ analyzer }, queries) {
     const { promotedQueries, requiresCfg } = promoteQueryCallNames(queries);
     let cfg = undefined;
     if (requiresCfg) {
-        cfg = await analyzer.controlflow([], true);
+        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)) {

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,20 @@ export declare enum CallTargets {
     /** call targets a function that is defined locally or globally */
     Any = "any"
 }
+/**
+ * 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';
+/**
+ * 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;
+/**
+ * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
+ */
 export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo): NodeId[];

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

@@ -28,6 +28,9 @@ var CallTargets;
     /** call targets a function that is defined locally or globally */
     CallTargets["Any"] = "any";
 })(CallTargets || (exports.CallTargets = 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) {
@@ -82,6 +85,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,6 +113,9 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
         return !additionalAllowedTypes || additionalAllowedTypes.includes(valueNode.type) ? valueNode : undefined;
     }
 }
+/**
+ * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
+ */
 function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
     if (ignoreIf?.(from, graph)) {
         return [];

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, 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,11 +14,11 @@ 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[]) => boolean;
+    readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
     readonly completer: typeof configReplCompleter;
     readonly fromLine: typeof configQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;

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>;