@eagleoutice/flowr 2.7.5 → 2.8.0

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-executor.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionsToConsiderInCallGraph = getFunctionsToConsiderInCallGraph;
+exports.executeExceptionQuery = executeExceptionQuery;
+const parse_1 = require("../../../slicing/criterion/parse");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const exceptions_of_function_1 = require("../../../dataflow/fn/exceptions-of-function");
+/**
+ * Get the functions to consider in the call graph based on the given queries.
+ */
+async function getFunctionsToConsiderInCallGraph(queries, analyzer, onlyDefinitions = true) {
+    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(q.filter);
+        }
+    }
+    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 cg = await analyzer.callGraph();
+    const fns = (onlyDefinitions || filterFor.size === 0 ? cg.verticesOfType(vertex_1.VertexType.FunctionDefinition) : cg.vertices(true))
+        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
+    return { cg, fns };
+}
+/**
+ * Execute exception function inspection queries on the given analyzer.
+ */
+async function executeExceptionQuery({ analyzer }, queries) {
+    const start = Date.now();
+    const { cg, fns } = await getFunctionsToConsiderInCallGraph(queries, analyzer);
+    const result = {};
+    for (const [id,] of fns) {
+        result[id] = (0, exceptions_of_function_1.calculateExceptionsOfFunction)(id, cg);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        exceptions: result
+    };
+}
+//# sourceMappingURL=inspect-exception-query-executor.js.map

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-format.d.ts

@@ -0,0 +1,34 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { ParsedQueryLine } from '../../query';
+import { executeExceptionQuery } from './inspect-exception-query-executor';
+import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
+import type { ExceptionPoint } from '../../../dataflow/fn/exceptions-of-function';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+/**
+ * Either returns all function definitions alongside exception information,
+ * or just those matching the filters.
+ */
+export interface InspectExceptionQuery extends BaseQueryFormat {
+    readonly type: 'inspect-exception';
+    /** If given, only function definitions that match one of the given slicing criteria are considered. */
+    readonly filter?: SingleSlicingCriterion[];
+}
+export interface InspectExceptionQueryResult extends BaseQueryResult {
+    /**
+     * If a function throws exceptions, the Ids of the throwing functions (at least the functions flowr knows about).
+     * An empty array means the function does not throw any exceptions.
+     */
+    readonly exceptions: Record<NodeId, ExceptionPoint[]>;
+}
+declare function inspectExceptionLineParser(_output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'inspect-exception'>;
+export declare const InspectExceptionQueryDefinition: {
+    readonly executor: typeof executeExceptionQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, processed: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly fromLine: typeof inspectExceptionLineParser;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};
+export {};

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-format.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectExceptionQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const inspect_exception_query_executor_1 = require("./inspect-exception-query-executor");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+const info_1 = require("../../../dataflow/info");
+function inspectExceptionLineParser(_output, line, _config) {
+    const criteria = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    return {
+        query: {
+            type: 'inspect-exception',
+            filter: criteria
+        },
+        rCode: criteria ? line[1] : line[0]
+    };
+}
+exports.InspectExceptionQueryDefinition = {
+    executor: inspect_exception_query_executor_1.executeExceptionQuery,
+    asciiSummarizer: async (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('inspect-exception', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        const n = await processed.normalize();
+        function getLoc(r) {
+            return n.idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r))?.location ?? undefined;
+        }
+        function getLexeme(r) {
+            return n.idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r))?.lexeme ?? String(r);
+        }
+        for (const [r, v] of Object.entries(out.exceptions)) {
+            result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${(0, dfg_1.formatRange)(getLoc(r))}) ${v.length > 0 ? 'throws exceptions:' : 'does not throw exceptions.'}`);
+            for (const { id: ex, cds } of v) {
+                result.push(`      - Exception ${(0, info_1.happensInEveryBranch)(cds) ? 'always ' : 'maybe '}thrown at id ${(0, ansi_1.bold)(String(ex), formatter)} "${getLexeme(ex)}" (${(0, dfg_1.formatRange)(getLoc(ex))}, cds: ${cds?.map(c => c.when + ':' + (0, dfg_1.formatRange)(getLoc(c.id))).join(', ') ?? 'none'})`);
+            }
+        }
+        return true;
+    },
+    fromLine: inspectExceptionLineParser,
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('inspect-exception').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('Query to inspect which functions throw exceptions.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.keys(out.exceptions).filter(id => out.exceptions[id].length > 0);
+    }
+};
+//# sourceMappingURL=inspect-exception-query-format.js.map

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

@@ -1,42 +1,17 @@
 "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");
+const inspect_exception_query_executor_1 = require("../inspect-exceptions-query/inspect-exception-query-executor");
 /**
  * Execute higher-order function inspection queries on the given analyzer.
  */
 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.verticesOfType(vertex_1.VertexType.FunctionDefinition)
-        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
+    const { cg, fns } = await (0, inspect_exception_query_executor_1.getFunctionsToConsiderInCallGraph)(queries, analyzer);
     const result = {};
     for (const [id,] of fns) {
-        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph, analyzer.inspectContext());
+        result[id] = (0, higher_order_function_1.isFunctionHigherOrder)(id, cg, analyzer.inspectContext());
     }
     return {
         '.meta': {

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

@@ -1,8 +1,11 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
+import type { ParsedQueryLine } from '../../query';
 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';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
 /**
  * Either returns all function definitions alongside whether they are higher-order functions,
  * or just those matching the filters.
@@ -14,9 +17,12 @@ export interface InspectHigherOrderQuery extends BaseQueryFormat {
 export interface InspectHigherOrderQueryResult extends BaseQueryResult {
     readonly higherOrder: Record<NodeId, boolean>;
 }
+declare function inspectHoLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'inspect-higher-order'>;
 export declare const InspectHigherOrderQueryDefinition: {
     readonly executor: typeof executeHigherOrderQuery;
     readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, processed: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly fromLine: typeof inspectHoLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };
+export {};

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

@@ -9,6 +9,17 @@ 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");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+function inspectHoLineParser(output, line, _config) {
+    const criteria = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    return {
+        query: {
+            type: 'inspect-higher-order',
+            filter: criteria
+        },
+        rCode: criteria ? line[1] : line[0]
+    };
+}
 exports.InspectHigherOrderQueryDefinition = {
     executor: inspect_higher_order_query_executor_1.executeHigherOrderQuery,
     asciiSummarizer: async (formatter, processed, queryResults, result) => {
@@ -20,6 +31,7 @@ exports.InspectHigherOrderQueryDefinition = {
         }
         return true;
     },
+    fromLine: inspectHoLineParser,
     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.')

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-executor.d.ts

@@ -0,0 +1,6 @@
+import type { InspectRecursionQuery, InspectRecursionQueryResult } from './inspect-recursion-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Execute recursion function inspection queries on the given analyzer.
+ */
+export declare function executeRecursionQuery({ analyzer }: BasicQueryData, queries: readonly InspectRecursionQuery[]): Promise<InspectRecursionQueryResult>;

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-executor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeRecursionQuery = executeRecursionQuery;
+const recursive_function_1 = require("../../../dataflow/fn/recursive-function");
+const inspect_exception_query_executor_1 = require("../inspect-exceptions-query/inspect-exception-query-executor");
+/**
+ * Execute recursion function inspection queries on the given analyzer.
+ */
+async function executeRecursionQuery({ analyzer }, queries) {
+    const start = Date.now();
+    const { cg, fns } = await (0, inspect_exception_query_executor_1.getFunctionsToConsiderInCallGraph)(queries, analyzer);
+    const result = {};
+    for (const [id,] of fns) {
+        result[id] = (0, recursive_function_1.isFunctionRecursive)(id, cg);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        recursive: result
+    };
+}
+//# sourceMappingURL=inspect-recursion-query-executor.js.map

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-format.d.ts

@@ -0,0 +1,28 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { ParsedQueryLine } from '../../query';
+import { executeRecursionQuery } from './inspect-recursion-query-executor';
+import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
+/**
+ * Either returns all function definitions alongside whether they are recursive,
+ * or just those matching the filters.
+ */
+export interface InspectRecursionQuery extends BaseQueryFormat {
+    readonly type: 'inspect-recursion';
+    readonly filter?: SingleSlicingCriterion[];
+}
+export interface InspectRecursionQueryResult extends BaseQueryResult {
+    readonly recursive: Record<NodeId, boolean>;
+}
+declare function inspectRecLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'inspect-recursion'>;
+export declare const InspectRecursionQueryDefinition: {
+    readonly executor: typeof executeRecursionQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, processed: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly fromLine: typeof inspectRecLineParser;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};
+export {};

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-format.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectRecursionQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const inspect_recursion_query_executor_1 = require("./inspect-recursion-query-executor");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+function inspectRecLineParser(output, line, _config) {
+    const criteria = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    return {
+        query: {
+            type: 'inspect-recursion',
+            filter: criteria
+        },
+        rCode: criteria ? line[1] : line[0]
+    };
+}
+exports.InspectRecursionQueryDefinition = {
+    executor: inspect_recursion_query_executor_1.executeRecursionQuery,
+    asciiSummarizer: async (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('inspect-recursion', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        for (const [r, v] of Object.entries(out.recursive)) {
+            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 '}recursive`);
+        }
+        return true;
+    },
+    fromLine: inspectRecLineParser,
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('inspect-recursion').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 recursive, or just those matching the filters.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.keys(out.recursive).filter(id => out.recursive[id]);
+    }
+};
+//# sourceMappingURL=inspect-recursion-query-format.js.map

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

@@ -125,6 +125,9 @@ function addLintingRuleResult(ruleName, results, result) {
             }
         }
     }
-    result.push(`       ╰ _Metadata_: ${(0, doc_code_1.codeInline)(JSON.stringify(results['.meta']))}`);
+    result.push(`       ╰ _Metadata_: ${(0, doc_code_1.codeInline)(renderMetaData(results['.meta']))}`);
+}
+function renderMetaData(metadata) {
+    return Object.entries(metadata).map(r => `${r[0]}: ${JSON.stringify(r[1])}`).join(', ');
 }
 //# sourceMappingURL=linter-query-format.js.map

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

@@ -20,7 +20,7 @@ function fuzzyFindFile(node, idMap) {
             return fuzzyFindFile(parent, idMap);
         }
     }
-    return '<inline>';
+    return '@inline';
 }
 /**
  * Executes a location map query

package/queries/catalog/normalized-ast-query/normalized-ast-query-executor.js

@@ -9,12 +9,13 @@ async function executeNormalizedAstQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Normalized-Ast query expects only up to one query, but got', queries.length);
     }
+    const startTime = Date.now();
+    const normalized = await analyzer.normalize();
     return {
         '.meta': {
-            /* there is no sense in measuring a get */
-            timing: 0
+            timing: Date.now() - startTime
         },
-        normalized: await analyzer.normalize()
+        normalized
     };
 }
 //# sourceMappingURL=normalized-ast-query-executor.js.map

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

@@ -10,6 +10,7 @@ async function executeProjectQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Project query expects only up to one query, but got', queries.length);
     }
+    const startTime = Date.now();
     const withDf = queries.some(q => q.withDf);
     // we need to know what is considered by the analyzer
     if (withDf) {
@@ -17,16 +18,21 @@ async function executeProjectQuery({ analyzer }, queries) {
     }
     const descFile = analyzer.inspectContext().files.getFilesByRole(flowr_file_1.FileRole.Description);
     const desc = descFile[0];
+    const roleCounts = {};
+    for (const file of Object.values(flowr_file_1.FileRole)) {
+        roleCounts[file] = analyzer.inspectContext().files.getFilesByRole(file).length;
+    }
     return {
         '.meta': {
-            /* there is no sense in measuring a get */
-            timing: 0
+            timing: Date.now() - startTime
         },
+        name: desc?.content().get('Package')?.[0] ?? desc?.content()?.get('Title')?.[0],
         files: Array.from(analyzer.inspectContext().files.consideredFilesList()),
         authors: desc?.authors(),
         encoding: desc?.content().get('Encoding')?.[0],
         version: desc?.content().get('Version')?.[0],
-        licenses: desc?.license()
+        licenses: desc?.license(),
+        roleCounts: roleCounts
     };
 }
 //# sourceMappingURL=project-query-executor.js.map

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

@@ -2,19 +2,24 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import { executeProjectQuery } from './project-query-executor';
 import Joi from 'joi';
 import type { RAuthorInfo } from '../../../util/r-author';
-import type { Info } from 'spdx-expression-parse';
+import type { RLicenseElementInfo } from '../../../util/r-license';
+import type { FileRole } from '../../../project/context/flowr-file';
 export interface ProjectQuery extends BaseQueryFormat {
     readonly type: 'project';
     /** Whether to include Dataflow information in the result. */
     readonly withDf?: boolean;
 }
 export interface ProjectQueryResult extends BaseQueryResult {
+    /** The name of the project, if available. */
+    readonly name?: string;
     /** The authors of the project. */
     readonly authors?: RAuthorInfo[];
     /** The files considered part of the project. */
     readonly files: (string | '<inline>')[];
+    /** The counts of files by their role in the project. */
+    readonly roleCounts?: Record<FileRole, number>;
     /** The licenses of the project. */
-    readonly licenses?: Info[];
+    readonly licenses?: RLicenseElementInfo[];
     /** The encoding of the project files. */
     readonly encoding?: string;
     /** The version of the project, if available. */
@@ -22,7 +27,7 @@ export interface ProjectQueryResult extends BaseQueryResult {
 }
 export declare const ProjectQueryDefinition: {
     readonly executor: typeof executeProjectQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -9,11 +9,18 @@ const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const r_author_1 = require("../../../util/r-author");
+const r_license_1 = require("../../../util/r-license");
+function addSuffix(count, singular = '', plural = 's') {
+    return `${count === 1 ? singular : plural}`;
+}
 exports.ProjectQueryDefinition = {
     executor: project_query_executor_1.executeProjectQuery,
-    asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
+    asciiSummarizer: (formatter, analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('project', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        if (out.name) {
+            result.push(`   ╰ Project Name: ${out.name}`);
+        }
         if (out.version) {
             result.push(`   ╰ Version: ${out.version}`);
         }
@@ -21,23 +28,42 @@ exports.ProjectQueryDefinition = {
             result.push(`   ╰ Encoding: ${out.encoding}`);
         }
         if (out.authors && out.authors.length > 0) {
-            result.push('   ╰ Author(s):');
+            result.push(`   ╰ Author${addSuffix(out.authors.length)}:`);
             for (const author of out.authors) {
                 result.push(`      ╰ ${(0, r_author_1.rAuthorInfoToReadable)(author)}`);
             }
         }
         if (out.licenses && out.licenses.length > 0) {
-            result.push('   ╰ License(s):');
+            result.push(`   ╰ License${addSuffix(out.licenses.length)}:`);
             for (const license of out.licenses) {
-                result.push(`      ╰ ${JSON.stringify(license)}`);
+                result.push(`      ╰ ${(0, r_license_1.stringifyRLicense)(license)}`);
+            }
+        }
+        if (out.roleCounts) {
+            const entries = Object.entries(out.roleCounts).filter(([, count]) => count > 0);
+            if (entries.length > 0) {
+                result.push('   ╰ File Role Counts:');
+                const longestRole = Math.max(...entries.map(([r]) => r.length));
+                const longestCount = Math.max(...entries.map(([, c]) => String(c).length));
+                for (const [role, count] of entries) {
+                    result.push(`      ╰ ${(role + ':').padEnd(longestRole + 1, ' ')} ${formatter.format(String(count).padStart(longestCount, ' '), {
+                        effect: ansi_1.ColorEffect.Foreground,
+                        color: 6 /* Colors.Cyan */
+                    })}`);
+                }
             }
         }
-        result.push(`   ╰ Dataflow Analysis considered ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
-        for (const file of out.files.slice(0, 20)) {
-            result.push(`      ╰ \`${file}\``);
+        if (analyzer.peekDataflow() === undefined) {
+            result.push(formatter.format('   ╰ Dataflow Analysis not performed', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground }));
         }
-        if (out.files.length > 20) {
-            result.push(`      ╰ ... and ${out.files.length - 20} more files`);
+        else {
+            result.push(`   ╰ Dataflow Analysis considered ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
+            for (const file of out.files.slice(0, 20)) {
+                result.push(`      ╰ \`${file}\``);
+            }
+            if (out.files.length > 20) {
+                result.push(`      ╰ ... and ${out.files.length - 20} more files`);
+            }
         }
         return true;
     },

package/queries/query.d.ts

@@ -29,10 +29,14 @@ import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
 import type { ReplOutput } from '../cli/repl/commands/repl-main';
 import type { CommandCompletions } from '../cli/repl/core';
 import type { FilesQuery } from './catalog/files-query/files-query-format';
+import type { CallGraphQuery } from './catalog/call-graph-query/call-graph-query-format';
+import type { InspectRecursionQuery } from './catalog/inspect-recursion-query/inspect-recursion-query-format';
+import type { DoesCallQuery } from './catalog/does-call-query/does-call-query-format';
+import type { InspectExceptionQuery } from './catalog/inspect-exceptions-query/inspect-exception-query-format';
 /**
  * These are all queries that can be executed from within flowR
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | FilesQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DoesCallQuery | CallGraphQuery | ControlFlowQuery | DataflowLensQuery | FilesQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectExceptionQuery | InspectHigherOrderQuery | InspectRecursionQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -86,12 +90,25 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
+    readonly 'call-graph': {
+        readonly executor: typeof import("./catalog/call-graph-query/call-graph-query-executor").executeCallGraphQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        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: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
+    readonly 'does-call': {
+        readonly executor: typeof import("./catalog/does-call-query/does-call-query-executor").executeDoesCallQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"does-call">;
+        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: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
@@ -164,9 +181,24 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
+    readonly 'inspect-exception': {
+        readonly executor: typeof import("./catalog/inspect-exceptions-query/inspect-exception-query-executor").executeExceptionQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly fromLine: (_output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"inspect-exception">;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
     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<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"inspect-higher-order">;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
+    readonly 'inspect-recursion': {
+        readonly executor: typeof import("./catalog/inspect-recursion-query/inspect-recursion-query-executor").executeRecursionQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"inspect-recursion">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
@@ -179,7 +211,7 @@ export declare const SupportedQueries: {
     };
     readonly project: {
         readonly executor: typeof import("./catalog/project-query/project-query-executor").executeProjectQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };