@eagleoutice/flowr 2.6.0 → 2.6.2

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

@@ -2,13 +2,17 @@
 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/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, 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, 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, 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';
+/**
+ *
+ */
 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");
+/**
+ *
+ */
 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, 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

@@ -27,7 +27,7 @@ exports.DefaultDependencyCategories = {
             if (!ignoreDefault) {
                 (0, visitor_1.visitAst)((await data.analyzer.normalize()).ast, 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 ast = await analyzer.normalize();
-    const graph = (await analyzer.dataflow()).graph;
+    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.flowrConfig);
     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, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly jsonFormatter: (queryResults: BaseQueryResult) => object;
+    readonly fromLine: typeof dfShapeQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };
+export {};

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

@@ -4,24 +4,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfShapeQueryDefinition = void 0;
+const dataframe_domain_1 = require("../../../abstract-interpretation/data-frame/dataframe-domain");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const joi_1 = __importDefault(require("joi"));
 const df_shape_query_executor_1 = require("./df-shape-query-executor");
-const json_1 = require("../../../util/json");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+const joi_1 = __importDefault(require("joi"));
+function dfShapeQueryLineParser(output, line, _config) {
+    const criterion = (0, slice_query_parser_1.sliceCriterionParser)(line[0]);
+    return {
+        query: {
+            type: 'df-shape',
+            criterion: criterion
+        },
+        rCode: criterion ? line[1] : line[0]
+    };
+}
 exports.DfShapeQueryDefinition = {
     executor: df_shape_query_executor_1.executeDfShapeQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
+        const domains = out.domains instanceof dataframe_domain_1.DataFrameStateDomain ? out.domains.value : out.domains;
         result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(...out.domains.entries().take(20).map(([key, domain]) => {
-            return `   ╰ ${key}: ${JSON.stringify(domain, json_1.jsonReplacer)}`;
+        result.push(...domains.entries().take(20).map(([key, domain]) => {
+            return `   ╰ ${key}: ${domain?.toString()}`;
         }));
-        if (out.domains.size > 20) {
+        if (domains.size > 20) {
             result.push('   ╰ ... (see JSON)');
         }
         return true;
     },
+    jsonFormatter: (queryResults) => {
+        const out = queryResults;
+        const domains = out.domains instanceof dataframe_domain_1.DataFrameStateDomain ? out.domains.value : out.domains;
+        const json = Object.fromEntries(domains.entries().map(([key, domain]) => [key, domain?.toJson()]));
+        return json;
+    },
+    fromLine: dfShapeQueryLineParser,
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('df-shape').required().description('The type of the query.'),
         criterion: joi_1.default.string().optional().description('The slicing criterion of the node to get the dataframe shape for.')

package/queries/catalog/happens-before-query/happens-before-query-executor.d.ts

@@ -1,3 +1,6 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { HappensBeforeQuery, HappensBeforeQueryResult } from './happens-before-query-format';
+/**
+ *
+ */
 export declare function executeHappensBefore({ analyzer }: BasicQueryData, queries: readonly HappensBeforeQuery[]): Promise<HappensBeforeQueryResult>;

package/queries/catalog/happens-before-query/happens-before-query-executor.js

@@ -6,6 +6,9 @@ const log_1 = require("../../../util/log");
 const extract_cfg_1 = require("../../../control-flow/extract-cfg");
 const happens_before_1 = require("../../../control-flow/happens-before");
 const parse_1 = require("../../../slicing/criterion/parse");
+/**
+ *
+ */
 async function executeHappensBefore({ analyzer }, queries) {
     const start = Date.now();
     const results = {};

package/queries/catalog/happens-before-query/happens-before-query-format.d.ts

@@ -13,7 +13,7 @@ export interface HappensBeforeQueryResult extends BaseQueryResult {
 }
 export declare const HappensBeforeQueryDefinition: {
     readonly executor: typeof executeHappensBefore;
-    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, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/id-map-query/id-map-query-executor.d.ts

@@ -1,3 +1,6 @@
 import type { IdMapQuery, IdMapQueryResult } from './id-map-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Executes the given ID map queries using the provided analyzer.
+ */
 export declare function executeIdMapQuery({ analyzer }: BasicQueryData, queries: readonly IdMapQuery[]): Promise<IdMapQueryResult>;

package/queries/catalog/id-map-query/id-map-query-executor.js

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

package/queries/catalog/id-map-query/id-map-query-format.d.ts

@@ -10,7 +10,7 @@ export interface IdMapQueryResult extends BaseQueryResult {
 }
 export declare const IdMapQueryDefinition: {
     readonly executor: typeof executeIdMapQuery;
-    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, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -0,0 +1,6 @@
+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>;

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHigherOrderQuery = executeHigherOrderQuery;
+const parse_1 = require("../../../slicing/criterion/parse");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const higher_order_function_1 = require("../../../dataflow/fn/higher-order-function");
+/**
+ *
+ */
+async function executeHigherOrderQuery({ analyzer }, queries) {
+    const start = Date.now();
+    let filters = undefined;
+    // filter will remain undefined if at least one of the queries wants all functions
+    for (const q of queries) {
+        if (q.filter === undefined) {
+            filters = undefined;
+            break;
+        }
+        else {
+            filters ??= [];
+            filters = filters.concat(filters);
+        }
+    }
+    const ast = await analyzer.normalize();
+    const filterFor = new Set();
+    if (filters) {
+        for (const f of filters) {
+            const i = (0, parse_1.tryResolveSliceCriterionToId)(f, ast.idMap);
+            if (i !== undefined) {
+                filterFor.add(i);
+            }
+        }
+    }
+    const graph = (await analyzer.dataflow()).graph;
+    const fns = graph.vertices(true)
+        .filter(([, v]) => (0, vertex_1.isFunctionDefinitionVertex)(v) && (filterFor.size === 0 || filterFor.has(v.id)));
+    const result = {};
+    for (const [id,] of fns) {
+        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        higherOrder: result
+    };
+}
+//# sourceMappingURL=inspect-higher-order-query-executor.js.map

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

@@ -0,0 +1,22 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeHigherOrderQuery } from './inspect-higher-order-query-executor';
+import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+/**
+ * Either returns all function definitions alongside whether they are higher-order functions,
+ * or just those matching the filters.
+ */
+export interface InspectHigherOrderQuery extends BaseQueryFormat {
+    readonly type: 'inspect-higher-order';
+    readonly filter?: SingleSlicingCriterion[];
+}
+export interface InspectHigherOrderQueryResult extends BaseQueryResult {
+    readonly higherOrder: Record<NodeId, boolean>;
+}
+export declare const InspectHigherOrderQueryDefinition: {
+    readonly executor: typeof executeHigherOrderQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, processed: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectHigherOrderQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const inspect_higher_order_query_executor_1 = require("./inspect-higher-order-query-executor");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const dfg_1 = require("../../../util/mermaid/dfg");
+exports.InspectHigherOrderQueryDefinition = {
+    executor: inspect_higher_order_query_executor_1.executeHigherOrderQuery,
+    asciiSummarizer: async (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('inspect-higher-order', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        for (const [r, v] of Object.entries(out.higherOrder)) {
+            const loc = (await processed.normalize()).idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r))?.location ?? undefined;
+            result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${(0, dfg_1.formatRange)(loc)}) is ${v ? '' : 'not '}a higher-order function`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('inspect-higher-order').required().description('The type of the query.'),
+        filter: joi_1.default.array().items(joi_1.default.string().required()).optional().description('If given, only function definitions that match one of the given slicing criteria are considered. Each criterion can be either `line:column`, `line@variable-name`, or `$id`, where the latter directly specifies the node id of the function definition to be considered.')
+    }).description('Either returns all function definitions alongside whether they are higher-order functions, or just those matching the filters.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.keys(out.higherOrder).filter(id => out.higherOrder[id]);
+    }
+};
+//# sourceMappingURL=inspect-higher-order-query-format.js.map

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

@@ -1,3 +1,7 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { LinterQuery, LinterQueryResult } from './linter-query-format';
+/**
+ * Executes the given linter queries using the provided analyzer.
+ * @see {@link executeLintingRule}
+ */
 export declare function executeLinterQuery({ analyzer }: BasicQueryData, queries: readonly LinterQuery[]): Promise<LinterQueryResult>;

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

@@ -4,6 +4,10 @@ exports.executeLinterQuery = executeLinterQuery;
 const linter_rules_1 = require("../../../linter/linter-rules");
 const log_1 = require("../../../util/log");
 const linter_executor_1 = require("../../../linter/linter-executor");
+/**
+ * Executes the given linter queries using the provided analyzer.
+ * @see {@link executeLintingRule}
+ */
 async function executeLinterQuery({ analyzer }, queries) {
     const flattened = queries.flatMap(q => q.rules ?? Object.keys(linter_rules_1.LintingRules));
     const distinct = new Set(flattened);

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

@@ -1,8 +1,12 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { ParsedQueryLine } from '../../query';
 import Joi from 'joi';
 import { executeLinterQuery } from './linter-query-executor';
-import type { LintingRuleNames } from '../../../linter/linter-rules';
-import type { ConfiguredLintingRule, LintingResults } from '../../../linter/linter-format';
+import { type LintingRuleNames } from '../../../linter/linter-rules';
+import { type ConfiguredLintingRule, type LintingResults } from '../../../linter/linter-format';
+import type { FlowrConfigOptions } from '../../../config';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { CommandCompletions } from '../../../cli/repl/core';
 export interface LinterQuery extends BaseQueryFormat {
     readonly type: 'linter';
     /**
@@ -19,9 +23,14 @@ export interface LinterQueryResult extends BaseQueryResult {
         [L in LintingRuleNames]?: LintingResults<L>;
     };
 }
+declare function linterQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'linter'>;
+declare function linterQueryCompleter(line: readonly string[], startingNewArg: boolean, _config: FlowrConfigOptions): CommandCompletions;
 export declare const LinterQueryDefinition: {
     readonly executor: typeof executeLinterQuery;
-    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, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly completer: typeof linterQueryCompleter;
+    readonly fromLine: typeof linterQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };
+export {};

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

@@ -11,6 +11,71 @@ const linter_format_1 = require("../../../linter/linter-format");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const doc_code_1 = require("../../../documentation/doc-util/doc-code");
+const retriever_1 = require("../../../r-bridge/retriever");
+function rulesFromInput(output, rulesPart) {
+    return rulesPart
+        .reduce((acc, ruleName) => {
+        ruleName = ruleName.trim();
+        if (ruleName in linter_rules_1.LintingRules) {
+            acc.valid.push(ruleName);
+        }
+        else {
+            acc.invalid.push(ruleName);
+        }
+        return acc;
+    }, { valid: [], invalid: [] });
+}
+const rulesPrefix = 'rules:';
+function linterQueryLineParser(output, line, _config) {
+    let rules = undefined;
+    let input = undefined;
+    if (line.length > 0 && line[0].startsWith(rulesPrefix)) {
+        const rulesPart = line[0].slice(rulesPrefix.length).split(',');
+        const parseResult = rulesFromInput(output, rulesPart);
+        if (parseResult.invalid.length > 0) {
+            output.stdout(`Invalid linting rule name(s): ${parseResult.invalid.map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`
+                + `\nValid rule names are: ${Object.keys(linter_rules_1.LintingRules).map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`);
+        }
+        rules = parseResult.valid;
+        input = line[1];
+    }
+    else if (line.length > 0) {
+        input = line[0];
+    }
+    return { query: [{ type: 'linter', rules: rules }], rCode: input };
+}
+function linterQueryCompleter(line, startingNewArg, _config) {
+    const rulesPrefixNotPresent = line.length == 0 || (line.length == 1 && line[0].length < rulesPrefix.length);
+    const rulesNotFinished = line.length == 1 && line[0].startsWith(rulesPrefix) && !startingNewArg;
+    const endOfRules = line.length == 1 && startingNewArg || line.length == 2;
+    if (rulesPrefixNotPresent) {
+        return { completions: [`${rulesPrefix}`] };
+    }
+    else if (endOfRules) {
+        return { completions: [retriever_1.fileProtocol] };
+    }
+    else if (rulesNotFinished) {
+        const rulesWithoutPrefix = line[0].slice(rulesPrefix.length);
+        const usedRules = rulesWithoutPrefix.split(',').map(r => r.trim());
+        const allRules = Object.keys(linter_rules_1.LintingRules);
+        const unusedRules = allRules.filter(r => !usedRules.includes(r));
+        const lastRule = usedRules[usedRules.length - 1];
+        const lastRuleIsUnfinished = !allRules.includes(lastRule);
+        if (lastRuleIsUnfinished) {
+            // Return all rules that have not been added yet
+            return { completions: unusedRules, argumentPart: lastRule };
+        }
+        else if (unusedRules.length > 0) {
+            // Add a comma, if the current last rule is complete
+            return { completions: [','], argumentPart: '' };
+        }
+        else {
+            // All rules are used, complete with a space
+            return { completions: [' '], argumentPart: '' };
+        }
+    }
+    return { completions: [] };
+}
 exports.LinterQueryDefinition = {
     executor: linter_query_executor_1.executeLinterQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
@@ -21,6 +86,8 @@ exports.LinterQueryDefinition = {
         }
         return true;
     },
+    completer: linterQueryCompleter,
+    fromLine: linterQueryLineParser,
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('linter').required().description('The type of the query.'),
         rules: joi_1.default.array().items(joi_1.default.string().valid(...Object.keys(linter_rules_1.LintingRules)), joi_1.default.object({

package/queries/catalog/location-map-query/location-map-query-executor.d.ts

@@ -1,3 +1,7 @@
 import type { LocationMapQuery, LocationMapQueryResult } from './location-map-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Executes a location map query
+ * @see {@link LocationMapQuery}
+ */
 export declare function executeLocationMapQuery({ analyzer }: BasicQueryData, queries: readonly LocationMapQuery[]): Promise<LocationMapQueryResult>;