@eagleoutice/flowr 2.6.0 → 2.6.1

package/dataflow/fn/higher-order-function.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHigherOrder = isHigherOrder;
+const vertex_1 = require("../graph/vertex");
+const assert_1 = require("../../util/assert");
+const edge_1 = require("../graph/edge");
+const alias_tracking_1 = require("../eval/resolve/alias-tracking");
+const config_1 = require("../../config");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const general_1 = require("../eval/values/general");
+function isAnyReturnAFunction(def, graph) {
+    const workingQueue = def.exitPoints.map(d => graph.getVertex(d, true)).filter(assert_1.isNotUndefined);
+    const seen = new Set();
+    while (workingQueue.length > 0) {
+        const current = workingQueue.pop();
+        if (seen.has(current.id)) {
+            continue;
+        }
+        seen.add(current.id);
+        if ((0, vertex_1.isFunctionDefinitionVertex)(current)) {
+            return true;
+        }
+        const next = graph.outgoingEdges(current.id) ?? [];
+        for (const [t, { types }] of next) {
+            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Returns)) {
+                const v = graph.getVertex(t, true);
+                if (v) {
+                    workingQueue.push(v);
+                }
+            }
+        }
+    }
+    return false;
+}
+function inspectCallSitesArgumentsFns(def, graph) {
+    const callSites = graph.ingoingEdges(def.id);
+    for (const [callerId, { types }] of callSites ?? []) {
+        if (!(0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls)) {
+            continue;
+        }
+        const caller = graph.getVertex(callerId, true);
+        if (!caller || !(0, vertex_1.isFunctionCallVertex)(caller)) {
+            continue;
+        }
+        for (const arg of caller.args) {
+            if (arg === r_function_call_1.EmptyArgument) {
+                continue;
+            }
+            const value = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.nodeId, { graph, idMap: graph.idMap, resolve: config_1.VariableResolve.Alias, full: true }));
+            if (value?.elements.some(e => e.type === 'function-definition')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Determines whether the function with the given id is a higher-order function, i.e.,
+ * either takes a function as an argument or (may) returns a function.
+ * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
+ * if no function is passed as an argument.
+ */
+function isHigherOrder(id, graph) {
+    const vert = graph.getVertex(id);
+    if (!vert || !(0, vertex_1.isFunctionDefinitionVertex)(vert)) {
+        return false;
+    }
+    // 1. check whether any of the exit types is a function
+    if (isAnyReturnAFunction(vert, graph)) {
+        return true;
+    }
+    // 2. check whether any of the callsites passes a function
+    return inspectCallSitesArgumentsFns(vert, graph);
+}
+//# sourceMappingURL=higher-order-function.js.map

package/documentation/doc-util/doc-repl.js

@@ -11,7 +11,7 @@ const doc_docker_1 = require("./doc-docker");
 const prompt_1 = require("../../cli/repl/prompt");
 const doc_code_1 = require("./doc-code");
 const print_version_1 = require("../../cli/repl/print-version");
-const config_1 = require("../../config");
+const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
 function printHelpForScript(script, starredVersion) {
     let base = `| **${(0, doc_cli_option_1.getReplCommand)(script[0], false, starredVersion !== undefined)}** | ${script[1].description}`;
     if (starredVersion) {
@@ -52,7 +52,10 @@ async function documentReplSession(parser, commands, options) {
                 entry.lines.push(msg);
             }
         };
-        await (0, core_1.replProcessAnswer)(config_1.defaultConfigOptions, collectingOutput, command.command, parser, options?.allowRSessionAccess ?? false);
+        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+            .setParser(parser)
+            .build();
+        await (0, core_1.replProcessAnswer)(analyzer, collectingOutput, command.command, options?.allowRSessionAccess ?? false);
         collect.push(entry);
     }
     let result = '';

package/documentation/print-dataflow-graph-wiki.js

@@ -921,8 +921,8 @@ ${(0, doc_types_1.printHierarchy)({ program: vertexType.program, info: vertexTyp
 Let's start by looking at the properties of the dataflow information object: ${Object.keys(result).map(k => `\`${k}\``).join(', ')}.
 
 ${(() => {
-            /* this includes the meta field for timing */
-            (0, assert_1.guard)(Object.keys(result).length === 8, () => 'Update Dataflow Documentation!');
+            /* this includes the meta field for timing and the quick CFG in order to enable re-use and improve performance */
+            (0, assert_1.guard)(Object.keys(result).length === 9, () => 'Update Dataflow Documentation!');
             return '';
         })()}
 

package/documentation/print-query-wiki.js

@@ -39,6 +39,7 @@ const doc_cfg_1 = require("./doc-util/doc-cfg");
 const df_shape_query_executor_1 = require("../queries/catalog/df-shape-query/df-shape-query-executor");
 const _00_slice_1 = require("../core/steps/all/static-slicing/00-slice");
 const doc_repl_1 = require("./doc-util/doc-repl");
+const inspect_higher_order_query_executor_1 = require("../queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -243,6 +244,25 @@ ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('inspect-higher-order', {
+    name: 'Inspect Higher-Order Functions Query',
+    type: 'active',
+    shortDescription: 'Determine whether functions are higher-order functions',
+    functionName: inspect_higher_order_query_executor_1.executeHigherOrderQuery.name,
+    functionFile: '../queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'f <- function() function(x) x; f()';
+        return `
+With this query you can identify which functions in the code are higher-order functions, i.e., either take a function as an argument or return a function.
+Please note, that functions that are just identities (e.g., \`function(x) x\`) are not considered higher-order if they do not take a function as an argument.
+
+Using the example code \`${exampleCode}\` the following query returns the information for all identified function definitions whether they are higher-order functions:
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'inspect-higher-order',
+            }], { showCode: true })}
+		`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('origin', {
     name: 'Origin Query',
     type: 'active',

package/documentation/print-readme.js

@@ -167,7 +167,7 @@ We welcome every contribution! Please check out the [developer onboarding](${doc
 
 ----
 
-*flowr* is actively developed by [Florian Sihler](https://eagleoutice.github.io/portfolio/) under the
+*flowr* is actively developed by [Florian Sihler](https://eagleoutice.github.io/portfolio/) and (since October 1st 2025) [Oliver Gerstl](https://www.linkedin.com/in/oliver-gerstl) under the
 [GPLv3 License](LICENSE).\\
 It is partially supported by the German Research Foundation (DFG) under the grant [504226141](https://gepris.dfg.de/gepris/projekt/504226141) ("CodeInspector").
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

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

@@ -10,6 +10,7 @@ import type { TreeSitterExecutor } from '../../r-bridge/lang-4.x/tree-sitter/tre
 import type { PipelineOutput } from '../../core/steps/pipeline/pipeline';
 import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
 import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+import { CfgKind } from '../cfg-kind';
 interface FlowrAnalyzerCacheOptions<Parser extends KnownParser> {
     parser: Parser;
     config: FlowrConfigOptions;
@@ -17,7 +18,7 @@ interface FlowrAnalyzerCacheOptions<Parser extends KnownParser> {
     getId?: IdGenerator<NoInfo>;
     overwriteFilePath?: string;
 }
-type AnalyzerCacheType<Parser extends KnownParser> = Parser extends TreeSitterExecutor ? Partial<PipelineOutput<typeof TREE_SITTER_DATAFLOW_PIPELINE>> : Partial<PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>;
+export type AnalyzerCacheType<Parser extends KnownParser> = Parser extends TreeSitterExecutor ? Partial<PipelineOutput<typeof TREE_SITTER_DATAFLOW_PIPELINE>> : Partial<PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>;
 /**
  * This provides the full analyzer caching layer, please avoid using this directly
  * and prefer the {@link FlowrAnalyzer}.
@@ -77,17 +78,17 @@ export declare class FlowrAnalyzerCache<Parser extends KnownParser> extends Flow
     /**
      * Get the control flow graph (CFG) for the request, computing if necessary.
      * @param force - Do not use the cache, instead force new analyses.
-     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param kind - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      */
-    controlflow(force: boolean | undefined, useDataflow: boolean, simplifications: readonly CfgSimplificationPassName[] | undefined): Promise<ControlFlowInformation>;
+    controlflow(force: boolean | undefined, kind: CfgKind, simplifications: readonly CfgSimplificationPassName[] | undefined): Promise<ControlFlowInformation>;
     /**
      * Get the control flow graph (CFG) for the request if already available, otherwise return `undefined`.
-     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param kind - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      *
      * @see {@link FlowrAnalyzerCache#controlflow} - to get the control flow graph, computing if necessary.
      */
-    peekControlflow(useDataflow: boolean, simplifications: readonly CfgSimplificationPassName[] | undefined): ControlFlowInformation | undefined;
+    peekControlflow(kind: CfgKind, simplifications: readonly CfgSimplificationPassName[] | undefined): ControlFlowInformation | undefined;
 }
 export {};

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

@@ -6,6 +6,7 @@ const default_pipelines_1 = require("../../core/steps/pipeline/default-pipelines
 const assert_1 = require("../../util/assert");
 const objectmap_1 = require("../../util/collections/objectmap");
 const extract_cfg_1 = require("../../control-flow/extract-cfg");
+const cfg_kind_1 = require("../cfg-kind");
 /**
  * This provides the full analyzer caching layer, please avoid using this directly
  * and prefer the {@link FlowrAnalyzer}.
@@ -50,6 +51,7 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
         this.receive({ type: "full" /* CacheInvalidationEventType.Full */ });
     }
     async runTapeUntil(force, until) {
+        (0, assert_1.guard)(this.args.request && (Array.isArray(this.args.request) ? this.args.request.length > 0 : true), 'At least one request must be set to run the analysis pipeline');
         if (force) {
             this.reset();
         }
@@ -119,37 +121,43 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
     /**
      * Get the control flow graph (CFG) for the request, computing if necessary.
      * @param force - Do not use the cache, instead force new analyses.
-     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param kind - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      */
-    async controlflow(force, useDataflow, simplifications) {
+    async controlflow(force, kind, simplifications) {
+        (0, assert_1.guard)(kind === cfg_kind_1.CfgKind.Quick ? simplifications === undefined : true, 'Cannot apply simplifications to quick CFG');
         simplifications ??= [];
         if (!force) {
-            const value = this.controlFlowCache.simplified.get([simplifications, useDataflow]);
+            const value = this.controlFlowCache.simplified.get([simplifications, kind]);
             if (value !== undefined) {
                 return value;
             }
         }
         const normalized = await this.normalize(force);
-        let dataflow = undefined;
-        if (useDataflow) {
-            /* if force is active, it will have triggered with normalize */
-            dataflow = await this.dataflow();
+        let result;
+        switch (kind) {
+            case cfg_kind_1.CfgKind.WithDataflow:
+                result = (0, extract_cfg_1.extractCfg)(normalized, this.args.config, (await this.dataflow()).graph, simplifications);
+                break;
+            case cfg_kind_1.CfgKind.NoDataflow:
+                result = (0, extract_cfg_1.extractCfg)(normalized, this.args.config, undefined, simplifications);
+                break;
+            case cfg_kind_1.CfgKind.Quick:
+                result = this.peekDataflow()?.cfgQuick ?? (0, extract_cfg_1.extractCfgQuick)(normalized);
+                break;
         }
-        const result = simplifications.length === 0 && !useDataflow ? (0, extract_cfg_1.extractCfgQuick)(normalized) :
-            (0, extract_cfg_1.extractCfg)(normalized, this.args.config, dataflow?.graph, simplifications);
-        this.controlFlowCache.simplified.set([simplifications, useDataflow], result);
+        this.controlFlowCache.simplified.set([simplifications, kind], result);
         return result;
     }
     /**
      * Get the control flow graph (CFG) for the request if already available, otherwise return `undefined`.
-     * @param useDataflow - Whether to use the dataflow graph for the creation of the CFG.
+     * @param kind - The kind of CFG that is requested.
      * @param simplifications - Simplification passes to be applied to the CFG.
      *
      * @see {@link FlowrAnalyzerCache#controlflow} - to get the control flow graph, computing if necessary.
      */
-    peekControlflow(useDataflow, simplifications) {
-        return this.controlFlowCache.simplified.get([simplifications ?? [], useDataflow]);
+    peekControlflow(kind, simplifications) {
+        return this.controlFlowCache.simplified.get([simplifications ?? [], kind]);
     }
 }
 exports.FlowrAnalyzerCache = FlowrAnalyzerCache;

package/project/cfg-kind.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Denotes the kind of control flow graph (CFG).
+ */
+export declare enum CfgKind {
+    /**
+     * CFG with dataflow information.
+     */
+    WithDataflow = 0,
+    /**
+     * CFG without dataflow information.
+     */
+    NoDataflow = 1,
+    /**
+     * A CFG version that is much quicker and does not apply any simplifications or dataflow information.
+     */
+    Quick = 2
+}

package/project/cfg-kind.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CfgKind = void 0;
+/**
+ * Denotes the kind of control flow graph (CFG).
+ */
+var CfgKind;
+(function (CfgKind) {
+    /**
+     * CFG with dataflow information.
+     */
+    CfgKind[CfgKind["WithDataflow"] = 0] = "WithDataflow";
+    /**
+     * CFG without dataflow information.
+     */
+    CfgKind[CfgKind["NoDataflow"] = 1] = "NoDataflow";
+    /**
+     * A CFG version that is much quicker and does not apply any simplifications or dataflow information.
+     */
+    CfgKind[CfgKind["Quick"] = 2] = "Quick";
+})(CfgKind || (exports.CfgKind = CfgKind = {}));
+//# sourceMappingURL=cfg-kind.js.map

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

@@ -32,4 +32,8 @@ export declare abstract class AbstractFlowrAnalyzerContext<In, Out, Plugin exten
      * Returns the project context this sub-context is attached to
      */
     getAttachedContext(): FlowrAnalyzerContext;
+    /**
+     * Reset the context to its initial state.
+     */
+    abstract reset(): void;
 }

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

@@ -37,6 +37,8 @@ export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContex
     constructor(plugins: ReadonlyMap<PluginType, readonly FlowrAnalyzerPlugin[]>);
     /** delegate request addition */
     addRequests(requests: readonly RAnalysisRequest[]): void;
+    /** delegate request addition */
+    addRequest(request: RAnalysisRequest): void;
     /** this conducts all the step that can be done before the main analysis run */
     resolvePreAnalysis(): void;
     /**
@@ -45,4 +47,8 @@ export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContex
      * the available methods.
      */
     inspect(): ReadOnlyFlowrAnalyzerContext;
+    /**
+     * Reset the context to its initial state, removing all files, dependencies, and loading orders.
+     */
+    reset(): void;
 }

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

@@ -29,6 +29,10 @@ class FlowrAnalyzerContext {
     addRequests(requests) {
         this.files.addRequests(requests);
     }
+    /** delegate request addition */
+    addRequest(request) {
+        this.files.addRequest(request);
+    }
     /** this conducts all the step that can be done before the main analysis run */
     resolvePreAnalysis() {
         this.files.computeLoadingOrder();
@@ -42,6 +46,13 @@ class FlowrAnalyzerContext {
     inspect() {
         return this;
     }
+    /**
+     * Reset the context to its initial state, removing all files, dependencies, and loading orders.
+     */
+    reset() {
+        this.files.reset();
+        this.deps.reset();
+    }
 }
 exports.FlowrAnalyzerContext = FlowrAnalyzerContext;
 //# sourceMappingURL=flowr-analyzer-context.js.map

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

@@ -31,6 +31,7 @@ export declare class FlowrAnalyzerDependenciesContext extends AbstractFlowrAnaly
     readonly name = "flowr-analyzer-dependencies-context";
     private dependencies;
     private staticsLoaded;
+    reset(): void;
     constructor(ctx: FlowrAnalyzerContext, plugins?: readonly FlowrAnalyzerPackageVersionsPlugin[]);
     resolveStaticDependencies(): void;
     addDependency(pkg: Package): void;

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

@@ -12,6 +12,10 @@ class FlowrAnalyzerDependenciesContext extends abstract_flowr_analyzer_context_1
     name = 'flowr-analyzer-dependencies-context';
     dependencies = new Map();
     staticsLoaded = false;
+    reset() {
+        this.dependencies = new Map();
+        this.staticsLoaded = false;
+    }
     constructor(ctx, plugins) {
         super(ctx, flowr_analyzer_package_versions_plugin_1.FlowrAnalyzerPackageVersionsPlugin.defaultPlugin(), plugins);
     }

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

@@ -59,6 +59,7 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
     private readonly fileLoaders;
     private specialFiles;
     constructor(loadingOrder: FlowrAnalyzerLoadingOrderContext, plugins: readonly FlowrAnalyzerProjectDiscoveryPlugin[], fileLoaders: readonly FlowrAnalyzerFilePlugin[]);
+    reset(): void;
     /**
      * Add multiple requests to the context. This is just a convenience method that calls {@link addRequest} for each request.
      */

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

@@ -49,6 +49,10 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
         this.fileLoaders = [...fileLoaders, flowr_analyzer_file_plugin_1.FlowrAnalyzerFilePlugin.defaultPlugin()];
         this.loadingOrder = loadingOrder;
     }
+    reset() {
+        this.loadingOrder.reset();
+        this.files = new Map();
+    }
     /**
      * Add multiple requests to the context. This is just a convenience method that calls {@link addRequest} for each request.
      */

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/flowr-analyzer.d.ts

@@ -1,15 +1,17 @@
 import type { FlowrConfigOptions } from '../config';
-import type { KnownParser, KnownParserName, ParseStepOutput } from '../r-bridge/parser';
+import type { KnownParser, ParseStepOutput, RShellInformation, TreeSitterInformation } from '../r-bridge/parser';
 import type { Queries, QueryResults, 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 { FlowrAnalyzerContext, ReadOnlyFlowrAnalyzerContext } from './context/flowr-analyzer-context';
+import { CfgKind } from './cfg-kind';
+import type { OutputCollectorConfiguration } from '../r-bridge/shell';
 /**
  * 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.
@@ -18,7 +20,13 @@ export interface FlowrAnalysisProvider {
     /**
      * Get the name of the parser used by the analyzer.
      */
-    parserName(): string;
+    parserInformation(): Promise<TreeSitterInformation | RShellInformation>;
+    /**
+     * Sends a command to the underlying R engine and collects the output.
+     * @param command     - The command to send to the R engine.
+     * @param addonConfig - Additional configuration for the output collector.
+     */
+    sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
     /**
      * Returns project context information.
      * If you are a user that wants to inspect the context, prefer {@link inspectContext} instead.
@@ -50,17 +58,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.
@@ -107,15 +108,15 @@ export declare class FlowrAnalyzer<Parser extends KnownParser = KnownParser> imp
      */
     constructor(config: FlowrConfigOptions, parser: Parser, ctx: FlowrAnalyzerContext, cache: FlowrAnalyzerCache<Parser>);
     context(): FlowrAnalyzerContext;
+    parserInformation(): Promise<TreeSitterInformation | RShellInformation>;
+    sendCommandWithOutput(command: string, addonConfig?: Partial<OutputCollectorConfiguration>): Promise<string[]>;
     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>;
+    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,9 @@ 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");
+const shell_1 = require("../r-bridge/shell");
+const assert_1 = require("../util/assert");
 /**
  * Central class for conducting analyses with FlowR.
  * Use the {@link FlowrAnalyzerBuilder} to create a new instance.
@@ -36,15 +39,22 @@ class FlowrAnalyzer {
     context() {
         return this.ctx;
     }
+    async parserInformation() {
+        return this.parser.name === 'r-shell' ?
+            { name: 'r-shell', rVersion: await this.parser.rVersion() }
+            : { name: 'tree-sitter' };
+    }
+    async sendCommandWithOutput(command, addonConfig) {
+        (0, assert_1.guard)(this.parser instanceof shell_1.RShell, 'sendCommandWithOutput can only be used with RShell parsers!');
+        return this.parser.sendCommandWithOutput(command, addonConfig);
+    }
     inspectContext() {
         return this.ctx.inspect();
     }
     reset() {
+        this.ctx.reset();
         this.cache.reset();
     }
-    parserName() {
-        return this.parser.name;
-    }
     async parse(force) {
         return this.cache.parse(force);
     }
@@ -58,11 +68,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/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);
@@ -184,7 +185,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/config-query/config-query-format.d.ts

@@ -15,7 +15,7 @@ declare function configReplCompleter(partialLine: readonly string[], config: Flo
 declare function configQueryLineParser(line: readonly string[], _config: FlowrConfigOptions): [ConfigQuery];
 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/control-flow-query/control-flow-query-executor.js

@@ -2,13 +2,14 @@
 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);
     }
     const query = queries[0];
     const start = Date.now();
-    const controlFlow = await analyzer.controlflow(query.config?.simplificationPasses, true);
+    const controlFlow = await analyzer.controlflow(query.config?.simplificationPasses, cfg_kind_1.CfgKind.WithDataflow);
     return {
         '.meta': {
             timing: Date.now() - start

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

@@ -9,8 +9,8 @@ async function executeDfShapeQuery({ analyzer }, queries) {
         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 ast = await analyzer.normalize();
     const graph = (await analyzer.dataflow()).graph;
+    const ast = await analyzer.normalize();
     const start = Date.now();
     const domains = (0, shape_inference_1.inferDataFrameShapes)(await analyzer.controlflow(), graph, ast, analyzer.flowrConfig);
     if (queries.length === 1 && queries[0].criterion === undefined) {

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { InspectHigherOrderQuery, InspectHigherOrderQueryResult } from './inspect-higher-order-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeHigherOrderQuery({ analyzer }: BasicQueryData, queries: readonly InspectHigherOrderQuery[]): Promise<InspectHigherOrderQueryResult>;