@eagleoutice/flowr 2.7.6 → 2.8.1

package/queries/catalog/call-graph-query/call-graph-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.CallGraphQueryDefinition = void 0;
+const call_graph_query_executor_1 = require("./call-graph-query-executor");
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const joi_1 = __importDefault(require("joi"));
+exports.CallGraphQueryDefinition = {
+    executor: call_graph_query_executor_1.executeCallGraphQuery,
+    asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('call-graph', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ [Call Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('call-graph').required().description('The type of the query.'),
+    }).description('A query to compute the Call Graph of the analyzed project.'),
+    flattenInvolvedNodes: queryResults => {
+        const flattened = [];
+        const out = queryResults;
+        for (const id of out.graph.idMap?.keys() ?? []) {
+            flattened.push(id);
+        }
+        return flattened;
+    }
+};
+//# sourceMappingURL=call-graph-query-format.js.map

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

@@ -9,12 +9,13 @@ 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);
     }
+    const startTime = Date.now();
+    const graph = (await analyzer.dataflow()).graph;
     return {
         '.meta': {
-            /* there is no sense in measuring a get */
-            timing: 0
+            timing: Date.now() - startTime
         },
-        graph: (await analyzer.dataflow()).graph
+        graph
     };
 }
 //# sourceMappingURL=dataflow-query-executor.js.map

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

@@ -79,17 +79,40 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
         const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue, data.analyzer.inspectContext());
         const linkedArgs = collectValuesFromLinks(args, { dataflow, config, ctx: data.analyzer.inspectContext() }, linkedIds);
         const linked = dropInfoOnLinkedIds(linkedIds);
+        function ignoreOnArgVal() {
+            if (info.ignoreIf === 'arg-true' || info.ignoreIf === 'arg-false') {
+                const margs = info.additionalArgs?.val;
+                (0, assert_1.guard)(margs, 'Need additional argument val when checking for arg-true');
+                const valArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
+                const valValues = valArgs?.values().flatMap(v => Array.from(v)).toArray() ?? [];
+                if (valValues.length === 0) {
+                    return false;
+                }
+                if (info.ignoreIf === 'arg-true' && valValues.every(v => v === 'TRUE')) {
+                    // all values are TRUE, so we can ignore this
+                    return true;
+                }
+                else if (info.ignoreIf === 'arg-false' && valValues.every(v => v === 'FALSE')) {
+                    // all values are FALSE, so we can ignore this
+                    return true;
+                }
+            }
+            return false;
+        }
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
             if (info.ignoreIf === 'arg-missing') {
                 return [];
             }
+            else if (ignoreOnArgVal()) {
+                return [];
+            }
             const record = (0, objects_1.compactRecord)({
                 nodeId: id,
                 functionName: vertex.name,
                 lexemeOfArgument: undefined,
                 linkedIds: linked?.length ? linked : undefined,
-                value: defaultValue
+                value: info.defaultValue ?? defaultValue
             });
             return record ? [record] : [];
         }
@@ -98,7 +121,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
             const margs = info.additionalArgs?.mode;
             (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
             const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue, data?.analyzer.inspectContext());
-            const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
+            const modeValues = modeArgs?.values().flatMap(v => Array.from(v)) ?? [];
             if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
                 // all modes are read-only, so we can ignore this
                 return [];
@@ -108,6 +131,9 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
                 return [];
             }
         }
+        else if (ignoreOnArgVal()) {
+            return [];
+        }
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {
@@ -117,7 +143,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
                     functionName: vertex.name,
                     lexemeOfArgument: getLexeme(value, arg),
                     linkedIds: linked?.length ? linked : undefined,
-                    value: value ?? defaultValue,
+                    value: value ?? info.defaultValue ?? defaultValue,
                     versionConstraints: dep?.versionConstraints,
                     derivedVersion: dep?.derivedVersion,
                     namespaceInfo: dep?.namespaceInfo

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

@@ -11,6 +11,7 @@ export declare const Unknown = "unknown";
 export interface DependencyCategorySettings {
     queryDisplayName?: string;
     functions: FunctionInfo[];
+    /** this describes the global default value for this category, e.g., 'stdout' for write operations, please be aware, that this can be overwritten by a by-function default value */
     defaultValue?: string;
     additionalAnalysis?: (data: BasicQueryData, ignoreDefault: boolean, functions: FunctionInfo[], queryResults: CallContextQueryResult, result: DependencyInfo[]) => AsyncOrSync<void>;
 }

package/queries/catalog/dependencies-query/function-info/function-info.d.ts

@@ -18,11 +18,18 @@ export interface FunctionArgInfo {
     argName?: string;
     resolveValue?: boolean | 'library';
 }
+/** Describes a function that may create a dependency */
 export interface FunctionInfo extends FunctionArgInfo {
+    /** Which package does the function belong to */
     package?: string;
+    /** The name of the function */
     name: string;
+    /** links to other function calls to get the dependency from there (e.g., with `sink` for `print`) */
     linkTo?: DependencyInfoLink[];
-    ignoreIf?: 'arg-missing' | 'mode-only-read' | 'mode-only-write';
+    /** default value for the argument if no binding value is found, please be aware, that categories can define global defaults, these are overwritten by the per-function defaults */
+    defaultValue?: string;
+    /** the function is not to be counted as a dependency if the argument is missing */
+    ignoreIf?: 'arg-missing' | 'mode-only-read' | 'mode-only-write' | 'arg-true' | 'arg-false';
     /** additional info on arguments - e.g. for the mode flag */
     additionalArgs?: Record<string, FunctionArgInfo>;
 }

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -14,6 +14,19 @@ exports.WriteFunctions = [
     { package: 'utils', name: 'write.table', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'utils', name: 'write.csv', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'base', name: 'saveRDS', argIdx: 1, argName: 'file', resolveValue: true },
+    {
+        package: 'base',
+        name: 'try',
+        linkTo: OutputRedirects,
+        argIdx: 2,
+        argName: 'outFile',
+        resolveValue: true,
+        defaultValue: 'stderr',
+        ignoreIf: 'arg-true',
+        additionalArgs: {
+            val: { argIdx: 1, argName: 'silent' }
+        }
+    },
     // write functions that don't have argIndex are assumed to write to stdout
     { package: 'base', name: 'print', linkTo: OutputRedirects, resolveValue: true },
     { package: 'base', name: 'cat', linkTo: OutputRedirects, argName: 'file', resolveValue: true },

package/queries/catalog/does-call-query/does-call-query-executor.d.ts

@@ -0,0 +1,6 @@
+import type { DoesCallQuery, DoesCallQueryResult } from './does-call-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Execute does call queries on the given analyzer.
+ */
+export declare function executeDoesCallQuery({ analyzer }: BasicQueryData, queries: readonly DoesCallQuery[]): Promise<DoesCallQueryResult>;

package/queries/catalog/does-call-query/does-call-query-executor.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDoesCallQuery = executeDoesCallQuery;
+const log_1 = require("../../../util/log");
+const parse_1 = require("../../../slicing/criterion/parse");
+const built_in_1 = require("../../../dataflow/environments/built-in");
+/**
+ * Execute does call queries on the given analyzer.
+ */
+async function executeDoesCallQuery({ analyzer }, queries) {
+    const start = Date.now();
+    const cg = await analyzer.callGraph();
+    const idMap = (await analyzer.normalize()).idMap;
+    const results = {};
+    for (const query of queries) {
+        const id = query.queryId ?? JSON.stringify(query);
+        if (id in results) {
+            log_1.log.warn(`Duplicate query id '${id}' in does-call queries, SKIP.`);
+            continue;
+        }
+        const nodeId = (0, parse_1.tryResolveSliceCriterionToId)(query.call, idMap);
+        if (!nodeId) {
+            results[id] = false;
+            continue;
+        }
+        const c = makeCallMatcher(query.calls);
+        results[id] = findCallersMatchingConstraints(cg, nodeId, c);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+function makeCallMatcher(constraint) {
+    switch (constraint.type) {
+        case 'calls-id':
+            return (vtx) => vtx.id === constraint.id;
+        case 'name':
+            if (constraint.nameExact) {
+                return (vtx) => vtx.name === constraint.name;
+            }
+            else {
+                const regex = new RegExp(constraint.name);
+                return (vtx) => 'name' in vtx && vtx.name ? regex.test(vtx.name) : false;
+            }
+        case 'and': {
+            let matchersAndRemain = constraint.calls.map(makeCallMatcher);
+            return (vtx, cg) => {
+                const matchersToRemove = [];
+                for (const matcher of matchersAndRemain) {
+                    if (matcher(vtx, cg)) {
+                        matchersToRemove.push(matcher);
+                    }
+                }
+                matchersAndRemain = matchersAndRemain.filter(m => !matchersToRemove.includes(m));
+                return matchersAndRemain.length === 0;
+            };
+        }
+        case 'or': {
+            const matchersOr = constraint.calls.map(makeCallMatcher);
+            return (vtx, cg) => matchersOr.some(m => m(vtx, cg));
+        }
+        default: {
+            throw new Error(`Unhandled constraint type ${JSON.stringify(constraint)}`);
+        }
+    }
+}
+function findCallersMatchingConstraints(cg, start, constraints) {
+    const visited = new Set();
+    const toVisit = [start];
+    while (toVisit.length > 0) {
+        const cur = toVisit.pop();
+        if (visited.has(cur)) {
+            continue;
+        }
+        visited.add(cur);
+        if ((0, built_in_1.isBuiltIn)(cur)) {
+            const name = (0, built_in_1.dropBuiltInPrefix)(cur);
+            if (constraints({ id: cur, name }, cg)) {
+                return { call: start };
+            }
+            continue;
+        }
+        const vtx = cg.getVertex(cur);
+        if (!vtx) {
+            continue;
+        }
+        // check if matches
+        if (constraints(vtx, cg)) {
+            return { call: start };
+        }
+        for (const out of cg.outgoingEdges(cur) ?? []) {
+            toVisit.push(out[0]);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=does-call-query-executor.js.map

package/queries/catalog/does-call-query/does-call-query-format.d.ts

@@ -0,0 +1,51 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { ParsedQueryLine } from '../../query';
+import { executeDoesCallQuery } from './does-call-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';
+interface CallsIdConstraint {
+    readonly type: 'calls-id';
+    /** The id of the function being called. */
+    readonly id: NodeId;
+}
+interface CallsWithNameConstraint {
+    readonly type: 'name';
+    /** The name of the function being called. */
+    readonly name: string;
+    /** Should we match the name exactly, or as a regex? */
+    readonly nameExact?: boolean;
+}
+interface CallsConstraints {
+    readonly type: 'and' | 'or' | 'one-of';
+    readonly calls: readonly CallsConstraint[];
+}
+export type CallsConstraint = CallsIdConstraint | CallsWithNameConstraint | CallsConstraints;
+/**
+ * Either checks whether a given function calls another function matching the given constraints,
+ * or returns all functions that call any function matching the given constraints.
+ */
+export interface DoesCallQuery extends BaseQueryFormat {
+    readonly type: 'does-call';
+    readonly queryId?: string;
+    readonly call: SingleSlicingCriterion;
+    readonly calls: CallsConstraint;
+}
+export interface FindAllCallsResult {
+    readonly call: NodeId;
+}
+export interface DoesCallQueryResult extends BaseQueryResult {
+    /** Results are either false (does not call) or an object with details on the calls made */
+    readonly results: Record<string, FindAllCallsResult | false>;
+}
+declare function doesCallQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'does-call'>;
+export declare const DoesCallQueryDefinition: {
+    readonly executor: typeof executeDoesCallQuery;
+    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 doesCallQueryLineParser;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};
+export {};

package/queries/catalog/does-call-query/does-call-query-format.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoesCallQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const does_call_query_executor_1 = require("./does-call-query-executor");
+const dfg_1 = require("../../../util/mermaid/dfg");
+const args_1 = require("../../../util/text/args");
+const strings_1 = require("../../../util/text/strings");
+const FormatError = 'Invalid constraint format, expected format "(left:$id/"regex")"';
+/**
+ * Parses a constraint from a string argument.
+ * Returns the constraint or an error message.
+ */
+function constraintParser(argument) {
+    if (!argument?.startsWith('(') || !argument.includes(')')) {
+        return FormatError + ` (got: "${argument}")`;
+    }
+    const endBracket = argument.indexOf(')');
+    const constrPart = argument.slice(1, endBracket);
+    const args = (0, args_1.splitAtEscapeSensitive)(constrPart, true, ':');
+    if (args.length !== 2) {
+        return FormatError + ` (got ${args.length} parts: ${args.join(', ')})`;
+    }
+    const [criteria, ...rhs] = args;
+    const rhsStr = rhs.join(' ');
+    if (rhsStr.startsWith('$')) {
+        return {
+            call: criteria,
+            constraint: {
+                type: 'calls-id',
+                id: rhsStr.slice(1),
+            }
+        };
+    }
+    else {
+        const isExact = (0, strings_1.startAndEndsWith)(rhsStr, '"');
+        const name = isExact ? rhsStr.slice(1, -1) : rhsStr;
+        return {
+            call: criteria,
+            constraint: {
+                type: 'name',
+                name: name,
+                nameExact: isExact ? true : undefined,
+            }
+        };
+    }
+}
+function doesCallQueryLineParser(output, line, _config) {
+    const constraint = constraintParser(line[0]);
+    if (!constraint || typeof constraint === 'string') {
+        output.stderr(output.formatter.format(`Invalid does-call query format:\n  ${constraint}`, { color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }));
+        return { query: [] };
+    }
+    return {
+        query: [
+            {
+                type: 'does-call',
+                queryId: constraint.call + ' (shorthand)',
+                call: constraint.call,
+                calls: constraint.constraint,
+            }
+        ],
+        rCode: line[1]
+    };
+}
+exports.DoesCallQueryDefinition = {
+    executor: does_call_query_executor_1.executeDoesCallQuery,
+    asciiSummarizer: async (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('does-call', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        for (const [r, v] of Object.entries(out.results)) {
+            const idMap = (await processed.normalize()).idMap;
+            result.push(`  - ${(0, ansi_1.bold)(r, formatter)} found:`);
+            if (v === false) {
+                result.push('    - Does not call any matching functions.');
+            }
+            else {
+                const loc = idMap.get(v.call)?.location ?? undefined;
+                result.push(`    - Call with id ${(0, ansi_1.bold)(String(v.call), formatter)} (${(0, dfg_1.formatRange)(loc)})`);
+            }
+        }
+        return true;
+    },
+    fromLine: doesCallQueryLineParser,
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('does-call').required().description('The type of the query.'),
+        queryId: joi_1.default.string().optional().description('An optional unique identifier for this query, to identify it in the output.'),
+        call: joi_1.default.string().description('The function from which calls are being made. This is a slicing criterion that resolves to a function definition node.'),
+        calls: joi_1.default.object().required().description('The constraints on which functions are being called. This can be a combination of name-based or id-based constraints, combined with logical operators (and, or, one-of).')
+    }).description('Either returns all function definitions alongside whether they are recursive, or just those matching the filters.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.entries(out.results).flatMap(([, v]) => {
+            return v !== false ? v.call : [];
+        });
+    }
+};
+//# sourceMappingURL=does-call-query-format.js.map

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

@@ -13,7 +13,7 @@ function executeFileQuery({ analyzer }, queries) {
     for (const query of queries) {
         if (query.matchesPathRegex === undefined && query.roles === undefined) {
             files = base.map(l => ({
-                role: l.role,
+                roles: l.roles,
                 content: l.content(),
                 path: l.path()
             }));
@@ -21,19 +21,19 @@ function executeFileQuery({ analyzer }, queries) {
         }
         const pathRegex = query.matchesPathRegex ? new RegExp(query.matchesPathRegex) : undefined;
         for (const file of base) {
-            const fingerprint = `${file.role}:::${file.path()}`;
+            const fingerprint = `${file.roles?.join(':')}:::${file.path()}`;
             if (foundFingerprints.has(fingerprint)) {
                 continue;
             }
             if (pathRegex && !pathRegex.test(file.path())) {
                 continue;
             }
-            if (query.roles && !query.roles.includes(file.role ?? '')) {
+            if ((query.roles?.length ?? 0) > 0 && !query.roles?.every(r => file.roles?.includes(r))) {
                 continue;
             }
             foundFingerprints.add(fingerprint);
             files.push({
-                role: file.role,
+                roles: file.roles,
                 content: file.content(),
                 path: file.path()
             });

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

@@ -12,11 +12,12 @@ import type { CommandCompletions } from '../../../cli/repl/core';
  */
 export interface FilesQuery extends BaseQueryFormat {
     readonly type: 'files';
+    /** If you provide roles, only files with all the given roles are returned. Supply multiple queries if you want a union! */
     readonly roles?: FileRole[];
     readonly matchesPathRegex?: string;
 }
 export interface FileQueryInfo<T = object> {
-    role?: FileRole;
+    roles?: readonly FileRole[];
     path: string;
     content: T;
 }

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

@@ -85,6 +85,21 @@ function filesQueryCompleter(line, startingNewArg, _config) {
     }
     return { completions: [] };
 }
+function guessProto(obj) {
+    if (obj === null || obj === undefined) {
+        return undefined;
+    }
+    else if (typeof obj !== 'object') {
+        return typeof obj;
+    }
+    else if ('prototype' in obj && obj.prototype && typeof obj.prototype === 'object') {
+        const proto = obj.prototype;
+        if (proto.constructor && typeof proto.constructor.name === 'string') {
+            return proto.constructor.name;
+        }
+    }
+    return undefined;
+}
 exports.FilesQueryDefinition = {
     executor: files_query_executor_1.executeFileQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
@@ -92,8 +107,9 @@ exports.FilesQueryDefinition = {
         result.push(`Query: ${(0, ansi_1.bold)('files', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
         result.push(`   ╰ Found ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
         for (const f of out.files) {
-            result.push(`      ╰ ${(0, ansi_1.bold)(f.path, formatter)}${f.role ? ` [role: ${f.role}]` : ''}:`);
-            const summary = summarizeObjectWithLimit(f.content);
+            const nam = guessProto(f.content);
+            result.push(`      ╰ ${(0, ansi_1.bold)(f.path, formatter)}${nam ? ' ' + formatter.format(nam, { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ }) : ''}${f.roles ? ` [role: ${f.roles.join(', ')}]` : ''}:`);
+            const summary = summarizeObjectWithLimit(f.content, 250);
             for (const line of summary.split('\n')) {
                 result.push(`          ${line}`);
             }

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

@@ -9,12 +9,13 @@ 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);
     }
+    const startTime = Date.now();
+    const idMap = (await analyzer.normalize()).idMap;
     return {
         '.meta': {
-            /* there is no sense in measuring a get */
-            timing: 0
+            timing: Date.now() - startTime
         },
-        idMap: (await analyzer.normalize()).idMap
+        idMap
     };
 }
 //# sourceMappingURL=id-map-query-executor.js.map

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

@@ -0,0 +1,18 @@
+import type { InspectExceptionQuery, InspectExceptionQueryResult } from './inspect-exception-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+import { type SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
+/**
+ * Get the functions to consider in the call graph based on the given queries.
+ */
+export declare function getFunctionsToConsiderInCallGraph(queries: readonly {
+    filter?: readonly SingleSlicingCriterion[];
+}[], analyzer: ReadonlyFlowrAnalysisProvider, onlyDefinitions?: boolean): Promise<{
+    cg: import("../../../dataflow/graph/call-graph").CallGraph;
+    fns: IteratorObject<[NodeId, Required<import("../../../dataflow/graph/vertex").DataflowGraphVertexFunctionCall | import("../../../dataflow/graph/vertex").DataflowGraphVertexFunctionDefinition>], undefined, unknown>;
+}>;
+/**
+ * Execute exception function inspection queries on the given analyzer.
+ */
+export declare function executeExceptionQuery({ analyzer }: BasicQueryData, queries: readonly InspectExceptionQuery[]): Promise<InspectExceptionQueryResult>;

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