@eagleoutice/flowr 2.6.0 → 2.6.2

package/queries/query.d.ts

@@ -1,46 +1,58 @@
-import type { CallContextQuery } from './catalog/call-context-query/call-context-query-format';
+import { type CallContextQuery } from './catalog/call-context-query/call-context-query-format';
 import type { BaseQueryFormat, BaseQueryResult, BasicQueryData } from './base-query-format';
-import type { VirtualQueryArgumentsWithType } from './virtual-query/virtual-queries';
+import { type VirtualQueryArgumentsWithType } from './virtual-query/virtual-queries';
 import type { VirtualCompoundConstraint } from './virtual-query/compound-query';
-import type { DataflowQuery } from './catalog/dataflow-query/dataflow-query-format';
-import type { IdMapQuery } from './catalog/id-map-query/id-map-query-format';
-import type { NormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-format';
-import type { LineageQuery } from './catalog/lineage-query/lineage-query-format';
-import type { StaticSliceQuery } from './catalog/static-slice-query/static-slice-query-format';
-import type { DataflowClusterQuery } from './catalog/cluster-query/cluster-query-format';
-import type { DependenciesQuery } from './catalog/dependencies-query/dependencies-query-format';
+import { type DataflowQuery } from './catalog/dataflow-query/dataflow-query-format';
+import { type IdMapQuery } from './catalog/id-map-query/id-map-query-format';
+import { type NormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-format';
+import { type StaticSliceQuery } from './catalog/static-slice-query/static-slice-query-format';
+import { type DataflowClusterQuery } from './catalog/cluster-query/cluster-query-format';
+import { type DependenciesQuery } from './catalog/dependencies-query/dependencies-query-format';
 import type { OutputFormatter } from '../util/text/ansi';
 import Joi from 'joi';
-import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
-import type { ConfigQuery } from './catalog/config-query/config-query-format';
-import type { SearchQuery } from './catalog/search-query/search-query-format';
-import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
-import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
-import type { DataflowLensQuery } from './catalog/dataflow-lens-query/dataflow-lens-query-format';
-import type { ProjectQuery } from './catalog/project-query/project-query-format';
-import type { OriginQuery } from './catalog/origin-query/origin-query-format';
-import type { LinterQuery } from './catalog/linter-query/linter-query-format';
+import { type LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
+import { type ConfigQuery } from './catalog/config-query/config-query-format';
+import { type SearchQuery } from './catalog/search-query/search-query-format';
+import { type HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
+import { type ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
+import { type DataflowLensQuery } from './catalog/dataflow-lens-query/dataflow-lens-query-format';
+import { type ProjectQuery } from './catalog/project-query/project-query-format';
+import { type OriginQuery } from './catalog/origin-query/origin-query-format';
+import { type LinterQuery } from './catalog/linter-query/linter-query-format';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
-import type { DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
+import { type ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
+import { type DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
 import type { AsyncOrSync } from 'ts-essentials';
 import type { FlowrConfigOptions } from '../config';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import { type InspectHigherOrderQuery } from './catalog/inspect-higher-order-query/inspect-higher-order-query-format';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReplOutput } from '../cli/repl/commands/repl-main';
+import type { CommandCompletions } from '../cli/repl/core';
 /**
  * These are all queries that can be executed from within flowR
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
 export type QueryExecutor<Query extends BaseQueryFormat, Result extends Promise<BaseQueryResult>> = (data: BasicQueryData, query: readonly Query[]) => Result;
+/**
+ * The result of parsing a query line from, e.g., the repl.
+ */
+export interface ParsedQueryLine<QueryType extends BaseQueryFormat['type']> {
+    /** The parsed query or queries from the line. */
+    query: QueryArgumentsWithType<QueryType> | QueryArgumentsWithType<QueryType>[] | undefined;
+    /** Optional R code associated with the query. */
+    rCode?: string;
+}
 export interface SupportedQuery<QueryType extends BaseQueryFormat['type'] = BaseQueryFormat['type']> {
     executor: QueryExecutor<QueryArgumentsWithType<QueryType>, Promise<BaseQueryResult>>;
     /** optional completion in, e.g., the repl */
-    completer?: (splitLine: readonly string[], config: FlowrConfigOptions) => string[];
+    completer?: (splitLine: readonly string[], startingNewArg: boolean, config: FlowrConfigOptions) => CommandCompletions;
     /** optional query construction from an, e.g., repl line */
-    fromLine?: (splitLine: readonly string[], config: FlowrConfigOptions) => Query | Query[] | undefined;
-    asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, resultStrings: string[], query: readonly Query[]) => AsyncOrSync<boolean>;
+    fromLine?: (output: ReplOutput, splitLine: readonly string[], config: FlowrConfigOptions) => ParsedQueryLine<QueryType>;
+    asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, resultStrings: string[], query: readonly Query[]) => AsyncOrSync<boolean>;
+    jsonFormatter?: (queryResults: BaseQueryResult) => object;
     schema: Joi.ObjectSchema;
     /**
      * Flattens the involved query nodes to be added to a flowR search when the {@link fromQuery} function is used based on the given result after this query is executed.
@@ -51,123 +63,136 @@ export interface SupportedQuery<QueryType extends BaseQueryFormat['type'] = Base
 export declare const SupportedQueries: {
     readonly 'call-context': {
         readonly executor: typeof import("./catalog/call-context-query/call-context-query-executor").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[];
     };
     readonly config: {
         readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
-        readonly completer: (partialLine: readonly string[], config: FlowrConfigOptions) => string[];
-        readonly fromLine: (line: readonly string[], _config: FlowrConfigOptions) => [ConfigQuery];
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly completer: (partialLine: readonly string[], _startingNewArg: boolean, config: FlowrConfigOptions) => CommandCompletions;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"config">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'control-flow': {
         readonly executor: typeof import("./catalog/control-flow-query/control-flow-query-executor").executeControlFlowQuery;
-        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[];
     };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'dataflow-lens': {
         readonly executor: typeof import("./catalog/dataflow-lens-query/dataflow-lens-query-executor").executeDataflowLensQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'df-shape': {
         readonly executor: typeof import("./catalog/df-shape-query/df-shape-query-executor").executeDfShapeQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly jsonFormatter: (queryResults: BaseQueryResult) => object;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"df-shape">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'normalized-ast': {
         readonly executor: typeof import("./catalog/normalized-ast-query/normalized-ast-query-executor").executeNormalizedAstQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'dataflow-cluster': {
         readonly executor: typeof import("./catalog/cluster-query/cluster-query-executor").executeDataflowClusterQuery;
-        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[];
     };
     readonly 'static-slice': {
         readonly executor: typeof import("./catalog/static-slice-query/static-slice-query-executor").executeStaticSliceQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
-        readonly schema: Joi.ObjectSchema<any>;
-        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
-    };
-    readonly lineage: {
-        readonly executor: typeof import("./catalog/lineage-query/lineage-query-executor").executeLineageQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"static-slice">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly dependencies: {
         readonly executor: typeof import("./catalog/dependencies-query/dependencies-query-executor").executeDependenciesQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly Query[]) => NodeId[];
     };
     readonly 'location-map': {
         readonly executor: typeof import("./catalog/location-map-query/location-map-query-executor").executeLocationMapQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"location-map">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly search: {
         readonly executor: typeof import("./catalog/search-query/search-query-executor").executeSearch;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'happens-before': {
         readonly executor: typeof import("./catalog/happens-before-query/happens-before-query-executor").executeHappensBefore;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
+    readonly 'inspect-higher-order': {
+        readonly executor: typeof import("./catalog/inspect-higher-order-query/inspect-higher-order-query-executor").executeHigherOrderQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
     readonly 'resolve-value': {
         readonly executor: typeof import("./catalog/resolve-value-query/resolve-value-query-executor").executeResolveValueQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"resolve-value">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly project: {
         readonly executor: typeof import("./catalog/project-query/project-query-executor").executeProjectQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly origin: {
         readonly executor: typeof import("./catalog/origin-query/origin-query-executor").executeResolveValueQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"origin">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly linter: {
         readonly executor: typeof import("./catalog/linter-query/linter-query-executor").executeLinterQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly completer: (line: readonly string[], startingNewArg: boolean, _config: FlowrConfigOptions) => CommandCompletions;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"linter">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = Promise<ReturnType<typeof SupportedQueries[Type]['executor']>>;
+/**
+ * Executes a set of queries that are all of the same type.
+ * Only use this function if you are sure all queries are of the same type.
+ * Otherwise, use {@link executeQueries}.
+ */
 export declare function executeQueriesOfSameType<SpecificQuery extends Query>(data: BasicQueryData, queries: readonly SpecificQuery[]): QueryResult<SpecificQuery['type']>;
 export type QueryResults<Base extends SupportedQueryTypes = SupportedQueryTypes> = {
     readonly [QueryType in Base]: Awaited<QueryResult<QueryType>>;
@@ -176,14 +201,27 @@ type OmitFromValues<T, K extends string | number | symbol> = {
     [P in keyof T]?: Omit<T[P], K>;
 };
 export type QueryResultsWithoutMeta<Queries extends Query> = OmitFromValues<Omit<QueryResults<Queries['type']>, '.meta'>, '.meta'>;
-export type Queries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
+export type Queries<Base extends SupportedQueryTypes = SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
 /**
  * This is the main query execution function that takes a set of queries and executes them on the given data.
+ * @see {@link executeQueriesOfSameType}
+ */
+export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): Promise<QueryResults<Base>>;
+/**
+ * Produces a Joi schema representing all supported queries.
  */
-export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): AsyncOrSync<QueryResults<Base>>;
 export declare function SupportedQueriesSchema(): Joi.AlternativesSchema<any>;
 export declare const CompoundQuerySchema: Joi.ObjectSchema<any>;
+/**
+ * Produces a Joi schema representing all virtual queries.
+ */
 export declare function VirtualQuerySchema(): Joi.AlternativesSchema<any>;
+/**
+ * Produces a Joi schema representing any supported query (including virtual queries).
+ */
 export declare function AnyQuerySchema(): Joi.AlternativesSchema<any>;
+/**
+ * Produces a Joi schema representing an array of supported queries.
+ */
 export declare function QueriesSchema(): Joi.ArraySchema<any[]>;
 export {};

package/queries/query.js

@@ -16,7 +16,6 @@ const virtual_queries_1 = require("./virtual-query/virtual-queries");
 const dataflow_query_format_1 = require("./catalog/dataflow-query/dataflow-query-format");
 const id_map_query_format_1 = require("./catalog/id-map-query/id-map-query-format");
 const normalized_ast_query_format_1 = require("./catalog/normalized-ast-query/normalized-ast-query-format");
-const lineage_query_format_1 = require("./catalog/lineage-query/lineage-query-format");
 const static_slice_query_format_1 = require("./catalog/static-slice-query/static-slice-query-format");
 const cluster_query_format_1 = require("./catalog/cluster-query/cluster-query-format");
 const dependencies_query_format_1 = require("./catalog/dependencies-query/dependencies-query-format");
@@ -32,6 +31,8 @@ const origin_query_format_1 = require("./catalog/origin-query/origin-query-forma
 const linter_query_format_1 = require("./catalog/linter-query/linter-query-format");
 const control_flow_query_format_1 = require("./catalog/control-flow-query/control-flow-query-format");
 const df_shape_query_format_1 = require("./catalog/df-shape-query/df-shape-query-format");
+const inspect_higher_order_query_format_1 = require("./catalog/inspect-higher-order-query/inspect-higher-order-query-format");
+const log_1 = require("../util/log");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -43,16 +44,21 @@ exports.SupportedQueries = {
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,
     'static-slice': static_slice_query_format_1.StaticSliceQueryDefinition,
-    'lineage': lineage_query_format_1.LineageQueryDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
     'search': search_query_format_1.SearchQueryDefinition,
     'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition,
+    'inspect-higher-order': inspect_higher_order_query_format_1.InspectHigherOrderQueryDefinition,
     'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition,
     'project': project_query_format_1.ProjectQueryDefinition,
     'origin': origin_query_format_1.OriginQueryDefinition,
     'linter': linter_query_format_1.LinterQueryDefinition
 };
+/**
+ * Executes a set of queries that are all of the same type.
+ * Only use this function if you are sure all queries are of the same type.
+ * Otherwise, use {@link executeQueries}.
+ */
 async function executeQueriesOfSameType(data, queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');
     /* every query must have the same type */
@@ -84,35 +90,34 @@ function groupQueriesByType(queries) {
     }
     return grouped;
 }
-function isPromiseLike(value) {
-    return value !== null && typeof value === 'object' && typeof value.then === 'function';
-}
 /**
  * This is the main query execution function that takes a set of queries and executes them on the given data.
+ * @see {@link executeQueriesOfSameType}
  */
-function executeQueries(data, queries) {
+async function executeQueries(data, queries) {
     const now = Date.now();
     const grouped = groupQueriesByType(queries);
     const entries = Object.entries(grouped);
-    const results = entries.map(([type, group]) => [type, executeQueriesOfSameType(data, group)]);
-    if (results.length === 0 || results.every(([_, r]) => !isPromiseLike(r))) {
-        // all results are synchronous, we can return them directly
-        const r = Object.fromEntries(results);
-        r['.meta'] = {
-            timing: Date.now() - now
-        };
-        return r;
+    const results = [];
+    for (const [type, group] of entries) {
+        try {
+            const result = await Promise.resolve(executeQueriesOfSameType(data, group));
+            results.push([type, result]);
+        }
+        catch (e) {
+            log_1.log.error(e);
+            results.push([type, undefined]);
+        }
     }
-    return Promise.all(results.map(([type, result]) => Promise.resolve(result).then(resolvedResult => [type, resolvedResult]).catch(() => {
-        return [type, undefined];
-    }))).then(resultsArray => {
-        const results = Object.fromEntries(resultsArray);
-        results['.meta'] = {
-            timing: Date.now() - now
-        };
-        return results;
-    });
+    const r = Object.fromEntries(results);
+    r['.meta'] = {
+        timing: Date.now() - now
+    };
+    return r;
 }
+/**
+ * Produces a Joi schema representing all supported queries.
+ */
 function SupportedQueriesSchema() {
     return joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
 }
@@ -122,12 +127,21 @@ exports.CompoundQuerySchema = joi_1.default.object({
     commonArguments: joi_1.default.object().required().description('Common arguments for all queries.'),
     arguments: joi_1.default.array().items(joi_1.default.object()).required().description('Arguments for each query.')
 }).description('Compound query used to combine queries of the same type');
+/**
+ * Produces a Joi schema representing all virtual queries.
+ */
 function VirtualQuerySchema() {
     return joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
 }
+/**
+ * Produces a Joi schema representing any supported query (including virtual queries).
+ */
 function AnyQuerySchema() {
     return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
 }
+/**
+ * Produces a Joi schema representing an array of supported queries.
+ */
 function QueriesSchema() {
     return joi_1.default.array().items(AnyQuerySchema()).description('Queries to run on the file analysis information (in the form of an array)');
 }

package/queries/virtual-query/virtual-queries.d.ts

@@ -1,6 +1,5 @@
 import type { QueryArgumentsWithType, SupportedQueryTypes } from '../query';
-import type { CompoundQueryFormat, VirtualCompoundConstraint } from './compound-query';
-import { executeCompoundQueries } from './compound-query';
+import { type CompoundQueryFormat, type VirtualCompoundConstraint, executeCompoundQueries } from './compound-query';
 import type { BaseQueryFormat } from '../base-query-format';
 /** A query that does not perform a search but may perform (e.g., convenience) modifications of other queries */
 export type VirtualQueryArgumentsWithType<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = CompoundQueryFormat<Base, VirtualArguments>;

package/r-bridge/data/get.d.ts

@@ -14,6 +14,12 @@ type PathToCapability = readonly number[];
 export interface FlowrCapabilityWithPath extends FlowrCapability {
     path: PathToCapability;
 }
+/**
+ * Find a flowR capability by its id.
+ */
 export declare function getCapabilityById(id: FlowrCapabilityId): FlowrCapabilityWithPath;
+/**
+ * Get all capabilities with their paths.
+ */
 export declare function getAllCapabilities(): readonly FlowrCapabilityWithPath[];
 export {};

package/r-bridge/data/get.js

@@ -21,6 +21,9 @@ function search(id, capabilities, path = []) {
     return undefined;
 }
 const capabilityCache = new Map();
+/**
+ * Find a flowR capability by its id.
+ */
 function getCapabilityById(id) {
     const cached = capabilityCache.get(id);
     if (cached) {
@@ -31,6 +34,9 @@ function getCapabilityById(id) {
     capabilityCache.set(id, value);
     return value;
 }
+/**
+ * Get all capabilities with their paths.
+ */
 function getAllCapabilities() {
     const result = [];
     function traverse(capabilities, currentPath = []) {

package/r-bridge/lang-4.x/ast/model/collect.d.ts

@@ -3,7 +3,6 @@ import type { NodeId } from './processing/node-id';
 import type { ParentInformation } from './processing/decorate';
 /**
  * Collects all node ids within a tree given by a respective root node
- *
  * @param nodes - The root id nodes to start collecting from
  * @param stop  - A function that determines whether to stop collecting at a given node, does not stop by default
  */

package/r-bridge/lang-4.x/ast/model/collect.js

@@ -4,7 +4,6 @@ exports.collectAllIds = collectAllIds;
 const visitor_1 = require("./processing/visitor");
 /**
  * Collects all node ids within a tree given by a respective root node
- *
  * @param nodes - The root id nodes to start collecting from
  * @param stop  - A function that determines whether to stop collecting at a given node, does not stop by default
  */

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -31,16 +31,16 @@ export type NoInfo = object;
  */
 interface Source {
     /**
-   * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
-   * element.
-   * <p>
-   * As an example for the difference, consider a for loop, the location of `for` will be just the three characters,
-   * but the *range* will be everything including the loop body.
-   */
+     * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
+     * element.
+     * <p>
+     * As an example for the difference, consider a for loop, the location of `for` will be just the three characters,
+     * but the *range* will be everything including the loop body.
+     */
     fullRange?: SourceRange;
     /**
-   * Similar to {@link Source.fullRange} this contains the complete R lexeme of the given element.
-   */
+     * Similar to {@link Source.fullRange} this contains the complete R lexeme of the given element.
+     */
     fullLexeme?: string;
     /**
      * This may contain additional elements that were part of the original R code, but are not part of the normalized R-ast.
@@ -54,7 +54,6 @@ interface Source {
 }
 /**
  * Provides the common base of all {@link RNode|RNodes}.
- *
  * @typeParam Info       - can be used to store additional information about the node
  * @typeParam LexemeType - the type of the lexeme, probably always a `string` or `string | undefined`
  */
@@ -85,7 +84,6 @@ export interface Location {
     /**
      * The location may differ from what is stated in {@link Source#fullRange} as it
      * represents the location identified by the R parser.
-     *
      * @see Source#fullRange
      */
     location: SourceRange;
@@ -144,7 +142,6 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * All other subtypes (like {@link RLoopConstructs}) listed above
  * can be used to restrict the kind of node. They do not have to be
  * exclusive, some nodes can appear in multiple subtypes.
- *
  * @see {@link recoverName} - to receive the name/lexeme from such a node
  * @see {@link recoverContent} - for a more rigorous approach to get the content of a node within a {@link DataflowGraph|dataflow graph}
  */

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.d.ts

@@ -6,7 +6,6 @@ export declare const EmptyArgument = "<>";
 export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
 /**
  * Calls of functions like `a()` and `foo(42, "hello")`.
- *
  * @see RUnnamedFunctionCall
  */
 export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
@@ -18,7 +17,6 @@ export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location
 }
 /**
  * Direct calls of functions like `(function(x) { x })(3)`.
- *
  * @see RNamedFunctionCall
  */
 export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {

package/r-bridge/lang-4.x/ast/model/nodes/r-number.d.ts

@@ -10,4 +10,7 @@ export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.Number;
     content: RNumberValue;
 }
+/**
+ * Checks whether the given node is an RNumber.
+ */
 export declare function isRNumber(node: RNode | undefined): node is RNumber;

package/r-bridge/lang-4.x/ast/model/nodes/r-number.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRNumber = isRNumber;
 const type_1 = require("../type");
+/**
+ * Checks whether the given node is an RNumber.
+ */
 function isRNumber(node) {
     return node?.type === type_1.RType.Number;
 }

package/r-bridge/lang-4.x/ast/model/nodes/r-string.d.ts

@@ -8,4 +8,7 @@ export interface RString<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.String;
     content: RStringValue;
 }
+/**
+ *
+ */
 export declare function isRString(node: RNode | undefined): node is RString;

package/r-bridge/lang-4.x/ast/model/nodes/r-string.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRString = isRString;
 const type_1 = require("../type");
+/**
+ *
+ */
 function isRString(node) {
     return node?.type === type_1.RType.String;
 }

package/r-bridge/lang-4.x/ast/model/nodes/r-symbol.d.ts

@@ -1,5 +1,8 @@
 import type { Leaf, Location, Namespace, NoInfo } from '../model';
 import type { RType } from '../type';
+/**
+ *
+ */
 export declare function isSpecialSymbol(symbol: RSymbol): boolean;
 /**
  * Represents identifiers (variables).

package/r-bridge/lang-4.x/ast/model/nodes/r-symbol.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSpecialSymbol = isSpecialSymbol;
 const convert_values_1 = require("../../../convert-values");
+/**
+ *
+ */
 function isSpecialSymbol(symbol) {
     return symbol.content === convert_values_1.RNull || symbol.content === convert_values_1.RNa;
 }

package/r-bridge/lang-4.x/ast/model/operators.d.ts

@@ -3,7 +3,6 @@ import { RawRType } from './type';
 import type { SupportedFlowrCapabilityId } from '../../../data/get';
 /**
  * Just a type-alias so that type declarations become more readable.
- *
  * @see OperatorDatabase
  */
 type StringUsedInRCode = string;