@eagleoutice/flowr 2.8.12 → 2.8.13

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

@@ -47,6 +47,7 @@ export type CallNameTypes = RegExp | string | string[];
  * This way, you can link a call like `points` to the latest graphics plot etc.
  * For now, this uses the static Control-Flow-Graph produced by flowR as the FD over-approximation is still not stable (see #1005).
  * In short, this means that we are unable to detect origins over function call boundaries but plan on being more precise in the future.
+ * @see LinkToNestedCall
  */
 export interface LinkToLastCall<CallName extends CallNameTypes = CallNameTypes> extends BaseQueryFormat {
     readonly type: 'link-to-last-call';
@@ -63,7 +64,26 @@ export interface LinkToLastCall<CallName extends CallNameTypes = CallNameTypes>
      */
     readonly cascadeIf?: (target: DataflowGraphVertexInfo, from: NodeId, graph: DataflowGraph) => CascadeAction;
 }
-export type LinkTo<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> = (LinkToLastCall<CallName>) & {
+/**
+ * Allows to link nested calls to their parent calls.
+ * This way, you can link an `assert_equal` call to the parent `test_that` call etc:
+ * ```r
+ * test_that("my test", {
+ *    assert_equal(1 + 1, 2)
+ * })
+ * ```
+ */
+export interface LinkToNestedCall<CallName extends CallNameTypes = CallNameTypes> extends BaseQueryFormat {
+    readonly type: 'link-to-nested-call';
+    /** Regex regarding the function name of the last call. Similar to {@link DefaultCallContextQueryFormat#callName}, strings are interpreted as a `RegExp`. */
+    readonly callName: CallName;
+    /**
+     * Should we ignore this (source) call?
+     * Currently, there is no well working serialization for this.
+     */
+    readonly ignoreIf?: (id: NodeId, graph: DataflowGraph) => boolean;
+}
+export type LinkTo<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> = (LinkToLastCall<CallName> | LinkToNestedCall<CallName>) & {
     attachLinkInfo?: AttachLinkInfo;
 };
 export interface SubCallContextQueryFormat<CallName extends CallNameTypes = CallNameTypes, AttachLinkInfo = NoInfo> extends DefaultCallContextQueryFormat<CallName> {

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

@@ -10,13 +10,21 @@ const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const query_print_1 = require("../../query-print");
 const identify_link_to_last_call_relation_1 = require("./identify-link-to-last-call-relation");
-const CallContextQueryLinkTo = joi_1.default.object({
-    type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
-    callName: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().items(joi_1.default.string())).required().description('Test regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression, and string arrays are checked for containment.'),
-    ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
-    cascadeIf: joi_1.default.function().optional().description('Should we continue searching after the link was created? Currently, there is no well working serialization for this.'),
-    attachLinkInfo: joi_1.default.object().optional().description('Additional information to attach to the link.')
-});
+const CallContextQueryLinkTo = joi_1.default.alternatives([
+    joi_1.default.object({
+        type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
+        callName: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().items(joi_1.default.string())).required().description('Test regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression, and string arrays are checked for containment.'),
+        ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
+        cascadeIf: joi_1.default.function().optional().description('Should we continue searching after the link was created? Currently, there is no well working serialization for this.'),
+        attachLinkInfo: joi_1.default.object().optional().description('Additional information to attach to the link.')
+    }).description('Links the current call to the last call of the given kind. This way, you can link a call like `points` to the latest graphics plot etc.'),
+    joi_1.default.object({
+        type: joi_1.default.string().valid('link-to-nested-call').required().description('The type of the linkTo sub-query.'),
+        callName: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().items(joi_1.default.string())).required().description('Test regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression, and string arrays are checked for containment.'),
+        ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
+        attachLinkInfo: joi_1.default.object().optional().description('Additional information to attach to the link.')
+    }).description('Allows to link nested calls to their parent calls. This way, you can link an `assert_equal` call to the parent `test_that` call etc.')
+]);
 exports.CallContextQueryDefinition = {
     executor: call_context_query_executor_1.executeCallContextQueries,
     asciiSummarizer: async (formatter, analyzer, queryResults, result) => {

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -3,9 +3,10 @@ import { type DataflowGraph } from '../../../dataflow/graph/graph';
 import { type DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
 import { RType } from '../../../r-bridge/lang-4.x/ast/model/type';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { LinkTo } from './call-context-query-format';
-import type { ControlFlowGraph } from '../../../control-flow/control-flow-graph';
+import type { LinkToLastCall } from './call-context-query-format';
 import type { PromotedLinkTo } from './call-context-query-executor';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
+import type { ControlFlowGraph } from '../../../control-flow/control-flow-graph';
 export declare enum CallTargets {
     /** call targets a function that is not defined locally in the script (e.g., the call targets a library function) */
     OnlyGlobal = "global",
@@ -32,9 +33,16 @@ export declare function getValueOfArgument<Types extends readonly RType[] = read
     type: Types[number];
 }) | undefined;
 /**
+ * **Please refer to {@link identifyLinkToRelation}.**
+ *
  * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
  * If you pass on `knownCalls` (e.g., produced by {@link getCallsInCfg}), this will only respect the functions
  * listed there and ignore any other calls. This can be also used to speed up the process if you already have
  * the known calls available.
+ * @see {@link identifyLinkToLastCallRelationSync} for the synchronous version.
+ */
+export declare function identifyLinkToLastCallRelation(from: NodeId, analyzer: ReadonlyFlowrAnalysisProvider, l: LinkToLastCall<RegExp> | PromotedLinkTo<LinkToLastCall<RegExp>>, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): Promise<NodeId[]>;
+/**
+ * Synchronous version of {@link identifyLinkToLastCallRelation}.
  */
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp> | PromotedLinkTo, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): NodeId[];
+export declare function identifyLinkToLastCallRelationSync(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, cascadeIf, ignoreIf }: LinkToLastCall<RegExp> | PromotedLinkTo<LinkToLastCall<RegExp>>, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -4,6 +4,7 @@ exports.CallTargets = void 0;
 exports.satisfiesCallTargets = satisfiesCallTargets;
 exports.getValueOfArgument = getValueOfArgument;
 exports.identifyLinkToLastCallRelation = identifyLinkToLastCallRelation;
+exports.identifyLinkToLastCallRelationSync = identifyLinkToLastCallRelationSync;
 const graph_1 = require("../../../dataflow/graph/graph");
 const simple_visitor_1 = require("../../../control-flow/simple-visitor");
 const vertex_1 = require("../../../dataflow/graph/vertex");
@@ -15,6 +16,7 @@ const assert_1 = require("../../../util/assert");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const cascade_action_1 = require("./cascade-action");
+const cfg_kind_1 = require("../../../project/cfg-kind");
 var CallTargets;
 (function (CallTargets) {
     /** call targets a function that is not defined locally in the script (e.g., the call targets a library function) */
@@ -111,12 +113,23 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
     }
 }
 /**
+ * **Please refer to {@link identifyLinkToRelation}.**
+ *
  * Identifies nodes that link to the last call of a specified function from a given starting node in the control flow graph.
  * If you pass on `knownCalls` (e.g., produced by {@link getCallsInCfg}), this will only respect the functions
  * listed there and ignore any other calls. This can be also used to speed up the process if you already have
  * the known calls available.
+ * @see {@link identifyLinkToLastCallRelationSync} for the synchronous version.
  */
-function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }, knownCalls) {
+async function identifyLinkToLastCallRelation(from, analyzer, l, knownCalls) {
+    const graph = (await analyzer.dataflow()).graph;
+    const cfg = (await analyzer.controlflow([], cfg_kind_1.CfgKind.WithDataflow)).graph;
+    return identifyLinkToLastCallRelationSync(from, cfg, graph, l, knownCalls);
+}
+/**
+ * Synchronous version of {@link identifyLinkToLastCallRelation}.
+ */
+function identifyLinkToLastCallRelationSync(from, cfg, graph, { callName, cascadeIf, ignoreIf }, knownCalls) {
     if (ignoreIf?.(from, graph)) {
         return [];
     }

package/queries/catalog/call-context-query/identify-link-to-nested-call-relation.d.ts

@@ -0,0 +1,12 @@
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { LinkToNestedCall } from './call-context-query-format';
+import type { PromotedLinkTo } from './call-context-query-executor';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
+/**
+ * **Please refer to {@link identifyLinkToRelation}.**
+ *
+ * Links to the nested call context of the current function call.
+ * This is useful for identifying calls made within nested functions
+ * that should be associated with their parent function's call context.
+ */
+export declare function identifyLinkToNestedRelation(from: NodeId, analyzer: ReadonlyFlowrAnalysisProvider, { callName, ignoreIf }: LinkToNestedCall<RegExp> | PromotedLinkTo<LinkToNestedCall<RegExp>>): Promise<NodeId[]>;

package/queries/catalog/call-context-query/identify-link-to-nested-call-relation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifyLinkToNestedRelation = identifyLinkToNestedRelation;
+const call_graph_1 = require("../../../dataflow/graph/call-graph");
+/**
+ * **Please refer to {@link identifyLinkToRelation}.**
+ *
+ * Links to the nested call context of the current function call.
+ * This is useful for identifying calls made within nested functions
+ * that should be associated with their parent function's call context.
+ */
+async function identifyLinkToNestedRelation(from, analyzer, { callName, ignoreIf }) {
+    const df = await analyzer.dataflow();
+    if (ignoreIf?.(from, df.graph)) {
+        return [];
+    }
+    const found = [];
+    const cg = await analyzer.callGraph();
+    const subCg = (0, call_graph_1.getSubCallGraph)(cg, new Set([from]));
+    for (const [, { id, name }] of subCg.vertices(true)) {
+        if (typeof name !== 'string') {
+            continue;
+        }
+        if (callName instanceof RegExp ? callName.test(name) : callName.has(name)) {
+            found.push(id);
+        }
+    }
+    return found;
+}
+//# sourceMappingURL=identify-link-to-nested-call-relation.js.map

package/queries/catalog/call-context-query/identify-link-to-relation.d.ts

@@ -0,0 +1,10 @@
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { LinkTo } from './call-context-query-format';
+import type { PromotedLinkTo } from './call-context-query-executor';
+import type { DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
+import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
+/**
+ * This facade selects the appropriate link-to relation identification function
+ * based on the type of link-to relation specified.
+ */
+export declare function identifyLinkToRelation(from: NodeId, analyzer: ReadonlyFlowrAnalysisProvider, l: LinkTo | PromotedLinkTo, knownCalls?: Map<NodeId, Required<DataflowGraphVertexFunctionCall>>): Promise<NodeId[]>;

package/queries/catalog/call-context-query/identify-link-to-relation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifyLinkToRelation = identifyLinkToRelation;
+const identify_link_to_last_call_relation_1 = require("./identify-link-to-last-call-relation");
+const identify_link_to_nested_call_relation_1 = require("./identify-link-to-nested-call-relation");
+const assert_1 = require("../../../util/assert");
+/**
+ * This facade selects the appropriate link-to relation identification function
+ * based on the type of link-to relation specified.
+ */
+async function identifyLinkToRelation(from, analyzer, l, knownCalls) {
+    switch (l.type) {
+        case 'link-to-last-call':
+            return (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(from, analyzer, l, knownCalls);
+        case 'link-to-nested-call':
+            return (0, identify_link_to_nested_call_relation_1.identifyLinkToNestedRelation)(from, analyzer, l);
+        default:
+            (0, assert_1.assertUnreachable)(l);
+    }
+}
+//# sourceMappingURL=identify-link-to-relation.js.map

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

@@ -84,7 +84,7 @@ function printResultSection(title, infos, result) {
     }, new Map());
     for (const [functionName, infos] of grouped) {
         result.push(`       ╰ \`${functionName}\``);
-        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}${i.value !== undefined ? `, \`${i.value}\`` : ''}${i.derivedVersion !== undefined ? `, Version: \`${i.derivedVersion.format()}\`` : ''}`).join('\n'));
+        result.push(infos.map(i => `           ╰ Node Id: ${i.nodeId}${i.value !== undefined ? `, \`${i.value}\`` : ''}${i.derivedVersion !== undefined ? `, Version: \`${i.derivedVersion.format()}\`` : ''}${i.linkedIds ? `, linked: [${i.linkedIds.join(', ')}]` : ''}`).join('\n'));
     }
 }
 /**

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

@@ -1,19 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestFunctions = void 0;
+const ExpectFunctions = {
+    type: 'link-to-nested-call',
+    callName: new RegExp(/* testthat */ '^(expect_equal|expect_identical|expect_error|expect_warning|expect_message|expect_condition|' +
+        'expect_true|expect_false|expect_all_equal|expect_all_true|expect_all_false|expect_lt|expect_lte|expect_gt|expect_gte|' +
+        'expect_length|expect_shape|expect_match|expect_no_match|expect_named|expect_null|expect_setequal|expect_mapequal|' +
+        'expect_contains|expect_in|expect_disjoint|expect_type|expect_s3_class|expect_s4_class|expect_r6_class|expect_s7_class|' +
+        'expect_vector|expect_no_error|expect_no_warning|expect_no_message|expect_no_condition|expect_invisible|expect_visible|' +
+        'expect_output|expect_silent|expect_snapshot|expect_snapshot_value|expect_snapshot_file|announce_snapshot_file|' +
+        'compare_file_binary|compare_file_text|snapshot_accept|snapshot_reject|snapshot_review|' +
+        'fail|pass|expect_success|expect_failure|expect_snapshot_failure|show_failure|' +
+        /* tinytest */
+        'exit_file|exit_if_not|expect_equal|expect_identical|expect_equivalent|expect_true|expect_false|expect_silent|expect_null|' +
+        'expect_inherits|expect_error|expect_warning|expect_message|expect_stdout|expect_equal_to_reference|' +
+        'expect_equivalent_to_reference|expect_length|expect_match|ignore|report_side_effects|' +
+        /* RUnit */
+        'checkEquals|checkEqualsNumeric|checkIdentical|checkTrue|checkException|' +
+        /* checkmate */
+        'assertAccess|assert_access|assertArray|assert_array|assert_atomic|assertAtomic|assert_atomic_vector|assertAtomicVector|' +
+        'assert_character|assertCharacter|assert_choice|assertChoice|assert_class|assertClass|assert_complex|assertComplex|' +
+        'assert_count|assertCount|assert_data_frame|assertDataFrame|assert_data_table|assertDataTable|assert_date|assertDate|' +
+        'assert_directory|assertDirectory|assert_directory_exists|assertDirectoryExists|assert_disjunct|assertDisjunct|assert_double|' +
+        'assertDouble|assert_environment|assertEnvironment|assert_factor|assertFactor|assert_false|assertFalse|assert_file|assertFile|' +
+        'assert_file_exists|assertFileExists|assert_flag|assertFlag|assert_formula|assertFormula|assert_function|assertFunction|' +
+        'assert_int|assertInt|assert_integer|assertInteger|assert_list|assertList|assert_logical|assertLogical|assert_matrix|' +
+        'assertMatrix|assert_multi_class|assertMultiClass|assert_named|assertNamed|assert_names|assertNames|assert_null|assertNull|' +
+        'assert_number|assertNumber|assert_numeric|assertNumeric|assert_os|assertOs|assert_path_for_output|assertPathForOutput|' +
+        'assert_permutation|assertPermutation|assert_posixct|assertPOSIXct|assert_r6|assertR6|assert_raw|assertRaw|assert_scalar|' +
+        'assertScalar|assert_scalar_na|assertScalarNA|assert_set_equal|assertSetEqual|assert_string|assertString|assert_subset|' +
+        'assertSubset|assert_tibble|assertTibble|assert_true|assertTrue|assert_vector|assertVector' +
+        ')$')
+};
+const ContextFunctions = {
+    type: 'link-to-last-call',
+    callName: new RegExp('^(context)$')
+};
 exports.TestFunctions = [
-    { package: 'testthat', name: 'test_that' },
-    { package: 'testthat', name: 'expect_equal' },
-    { package: 'testthat', name: 'expect_identical' },
-    { package: 'testthat', name: 'expect_error' },
-    { package: 'testthat', name: 'expect_warning' },
-    { package: 'testthat', name: 'expect_message' },
-    { package: 'testthat', name: 'expect_condition' },
-    { package: 'testthat', name: 'expect_true' },
-    { package: 'testthat', name: 'expect_false' },
-    { package: 'testthat', name: 'expect_all_equal' },
-    { package: 'testthat', name: 'expect_all_true' },
-    { package: 'testthat', name: 'expect_all_false' },
+    { package: 'testthat', name: 'test_that', argName: 'desc', argIdx: 0, resolveValue: true, linkTo: [ExpectFunctions, ContextFunctions] },
+    { package: 'testthat', name: 'describe', argName: 'description', argIdx: 0, resolveValue: true, linkTo: [ExpectFunctions, ContextFunctions] },
+    { package: 'testthat', name: 'it', argName: 'description', argIdx: 0, resolveValue: true, linkTo: [ExpectFunctions, ContextFunctions] },
+    /* for now we do not want to list them extra:
     { package: 'testthat', name: 'expect_lt' },
     { package: 'testthat', name: 'expect_lte' },
     { package: 'testthat', name: 'expect_gt' },
@@ -58,6 +85,7 @@ exports.TestFunctions = [
     { package: 'testthat', name: 'expect_failure' },
     { package: 'testthat', name: 'expect_snapshot_failure' },
     { package: 'testthat', name: 'show_failure' },
+
     { package: 'tinytest', name: 'exit_file', argName: 'msg', resolveValue: true },
     { package: 'tinytest', name: 'exit_if_not' },
     { package: 'tinytest', name: 'expect_equal', argName: 'info', resolveValue: true },
@@ -78,5 +106,111 @@ exports.TestFunctions = [
     { package: 'tinytest', name: 'expect_match', argName: 'info', resolveValue: true },
     { package: 'tinytest', name: 'ignore' },
     { package: 'tinytest', name: 'report_side_effects' },
+
+    { package: 'RUnit', name: 'checkEquals', argName: 'msg', argIdx: 2, resolveValue: true },
+    { package: 'RUnit', name: 'checkEqualsNumeric', argName: 'msg', argIdx: 2, resolveValue: true },
+    { package: 'RUnit', name: 'checkIdentical', argName: 'msg', argIdx: 2, resolveValue: true },
+    { package: 'RUnit', name: 'checkTrue', argName: 'msg', argIdx: 1, resolveValue: true },
+    { package: 'RUnit', name: 'checkException', argName: 'msg', argIdx: 1, resolveValue: true },
+
+    { package: 'checkmate', name: 'assertAccess' },
+    { package: 'checkmate', name: 'assert_access' },
+    { package: 'checkmate', name: 'assertArray' },
+    { package: 'checkmate', name: 'assert_array' },
+    { package: 'checkmate', name: 'assert_atomic' },
+    { package: 'checkmate', name: 'assertAtomic' },
+    { package: 'checkmate', name: 'assert_atomic_vector' },
+    { package: 'checkmate', name: 'assertAtomicVector' },
+    { package: 'checkmate', name: 'assert_character' },
+    { package: 'checkmate', name: 'assertCharacter' },
+    { package: 'checkmate', name: 'assert_choice' },
+    { package: 'checkmate', name: 'assertChoice' },
+    { package: 'checkmate', name: 'assert_class' },
+    { package: 'checkmate', name: 'assertClass' },
+    { package: 'checkmate', name: 'assert_complex' },
+    { package: 'checkmate', name: 'assertComplex' },
+    { package: 'checkmate', name: 'assert_count' },
+    { package: 'checkmate', name: 'assertCount' },
+    { package: 'checkmate', name: 'assert_data_frame' },
+    { package: 'checkmate', name: 'assertDataFrame' },
+    { package: 'checkmate', name: 'assert_data_table' },
+    { package: 'checkmate', name: 'assertDataTable' },
+    { package: 'checkmate', name: 'assert_date' },
+    { package: 'checkmate', name: 'assertDate' },
+    { package: 'checkmate', name: 'assert_directory' },
+    { package: 'checkmate', name: 'assertDirectory' },
+    { package: 'checkmate', name: 'assert_directory_exists' },
+    { package: 'checkmate', name: 'assertDirectoryExists' },
+    { package: 'checkmate', name: 'assert_disjunct' },
+    { package: 'checkmate', name: 'assertDisjunct' },
+    { package: 'checkmate', name: 'assert_double' },
+    { package: 'checkmate', name: 'assertDouble' },
+    { package: 'checkmate', name: 'assert_environment' },
+    { package: 'checkmate', name: 'assertEnvironment' },
+    { package: 'checkmate', name: 'assert_factor' },
+    { package: 'checkmate', name: 'assertFactor' },
+    { package: 'checkmate', name: 'assert_false' },
+    { package: 'checkmate', name: 'assertFalse' },
+    { package: 'checkmate', name: 'assert_file' },
+    { package: 'checkmate', name: 'assertFile' },
+    { package: 'checkmate', name: 'assert_file_exists' },
+    { package: 'checkmate', name: 'assertFileExists' },
+    { package: 'checkmate', name: 'assert_flag' },
+    { package: 'checkmate', name: 'assertFlag' },
+    { package: 'checkmate', name: 'assert_formula' },
+    { package: 'checkmate', name: 'assertFormula' },
+    { package: 'checkmate', name: 'assert_function' },
+    { package: 'checkmate', name: 'assertFunction' },
+    { package: 'checkmate', name: 'assert_int' },
+    { package: 'checkmate', name: 'assertInt' },
+    { package: 'checkmate', name: 'assert_integer' },
+    { package: 'checkmate', name: 'assertInteger' },
+    { package: 'checkmate', name: 'assert_list' },
+    { package: 'checkmate', name: 'assertList' },
+    { package: 'checkmate', name: 'assert_logical' },
+    { package: 'checkmate', name: 'assertLogical' },
+    { package: 'checkmate', name: 'assert_matrix' },
+    { package: 'checkmate', name: 'assertMatrix' },
+    { package: 'checkmate', name: 'assert_multi_class' },
+    { package: 'checkmate', name: 'assertMultiClass' },
+    { package: 'checkmate', name: 'assert_named' },
+    { package: 'checkmate', name: 'assertNamed' },
+    { package: 'checkmate', name: 'assert_names' },
+    { package: 'checkmate', name: 'assertNames' },
+    { package: 'checkmate', name: 'assert_null' },
+    { package: 'checkmate', name: 'assertNull' },
+    { package: 'checkmate', name: 'assert_number' },
+    { package: 'checkmate', name: 'assertNumber' },
+    { package: 'checkmate', name: 'assert_numeric' },
+    { package: 'checkmate', name: 'assertNumeric' },
+    { package: 'checkmate', name: 'assert_os' },
+    { package: 'checkmate', name: 'assertOs' },
+    { package: 'checkmate', name: 'assert_path_for_output' },
+    { package: 'checkmate', name: 'assertPathForOutput' },
+    { package: 'checkmate', name: 'assert_permutation' },
+    { package: 'checkmate', name: 'assertPermutation' },
+    { package: 'checkmate', name: 'assert_posixct' },
+    { package: 'checkmate', name: 'assertPOSIXct' },
+    { package: 'checkmate', name: 'assert_r6' },
+    { package: 'checkmate', name: 'assertR6' },
+    { package: 'checkmate', name: 'assert_raw' },
+    { package: 'checkmate', name: 'assertRaw' },
+    { package: 'checkmate', name: 'assert_scalar' },
+    { package: 'checkmate', name: 'assertScalar' },
+    { package: 'checkmate', name: 'assert_scalar_na' },
+    { package: 'checkmate', name: 'assertScalarNA' },
+    { package: 'checkmate', name: 'assert_set_equal' },
+    { package: 'checkmate', name: 'assertSetEqual' },
+    { package: 'checkmate', name: 'assert_string' },
+    { package: 'checkmate', name: 'assertString' },
+    { package: 'checkmate', name: 'assert_subset' },
+    { package: 'checkmate', name: 'assertSubset' },
+    { package: 'checkmate', name: 'assert_tibble' },
+    { package: 'checkmate', name: 'assertTibble' },
+    { package: 'checkmate', name: 'assert_true' },
+    { package: 'checkmate', name: 'assertTrue' },
+    { package: 'checkmate', name: 'assert_vector' },
+    { package: 'checkmate', name: 'assertVector' }
+     */
 ];
 //# sourceMappingURL=test-functions.js.map

package/queries/query.js

@@ -149,7 +149,7 @@ function VirtualQuerySchema() {
  * Produces a Joi schema representing any supported query (including virtual queries).
  */
 function AnyQuerySchema() {
-    return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
+    return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('A virtual or an active query!');
 }
 /**
  * Produces a Joi schema representing an array of supported queries.

package/search/search-executor/search-enrichers.d.ts

@@ -1,5 +1,5 @@
 import type { FlowrSearchElement, FlowrSearchElements } from '../flowr-search';
-import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type MergeableRecord } from '../../util/objects';
 import type { Identifier } from '../../dataflow/environments/identifier';
 import type { LinkToLastCall } from '../../queries/catalog/call-context-query/call-context-query-format';
@@ -9,18 +9,11 @@ import type { Query, QueryResult } from '../../queries/query';
 import { type CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
 import type { AsyncOrSync } from 'ts-essentials';
 import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
-import type { DataflowInformation } from '../../dataflow/info';
-import type { FlowrConfigOptions } from '../../config';
 export interface EnrichmentData<ElementContent extends MergeableRecord, ElementArguments = undefined, SearchContent extends MergeableRecord = never, SearchArguments = ElementArguments> {
     /**
      * A function that is applied to each element of the search to enrich it with additional data.
      */
-    readonly enrichElement?: (element: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation>, data: {
-        dataflow: DataflowInformation;
-        normalize: NormalizedAst;
-        cfg: ControlFlowInformation;
-        config: FlowrConfigOptions;
-    }, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => AsyncOrSync<ElementContent>;
+    readonly enrichElement?: (element: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation>, analyzer: ReadonlyFlowrAnalysisProvider, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => AsyncOrSync<ElementContent>;
     readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: ReadonlyFlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
     /**
      * The mapping function used by the {@link Mapper.Enrichment} mapper.
@@ -96,44 +89,24 @@ export interface QueryDataSearchContent extends MergeableRecord {
  */
 export declare const Enrichments: {
     readonly "call-targets": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: {
-            dataflow: DataflowInformation;
-            normalize: NormalizedAst;
-            cfg: ControlFlowInformation;
-            config: FlowrConfigOptions;
-        }, args: {
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, analyzer: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: {
             onlyBuiltin?: boolean;
-        } | undefined, prev: CallTargetsContent | undefined) => CallTargetsContent;
+        } | undefined, prev: CallTargetsContent | undefined) => Promise<CallTargetsContent>;
         mapper: ({ targets }: CallTargetsContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "last-call": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: {
-            dataflow: DataflowInformation;
-            normalize: NormalizedAst;
-            cfg: ControlFlowInformation;
-            config: FlowrConfigOptions;
-        }, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, analyzer: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => Promise<LastCallContent>;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "cfg-information": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
-            dataflow: DataflowInformation;
-            normalize: NormalizedAst;
-            cfg: ControlFlowInformation;
-            config: FlowrConfigOptions;
-        }, _args: CfgInformationArguments | undefined, prev: CfgInformationElementContent | undefined) => {
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, _args: CfgInformationArguments | undefined, prev: CfgInformationElementContent | undefined) => {
             isRoot: boolean;
             isReachable: boolean | undefined;
         };
         enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
     };
     readonly "query-data": {
-        enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
-            dataflow: DataflowInformation;
-            normalize: NormalizedAst;
-            cfg: ControlFlowInformation;
-            config: FlowrConfigOptions;
-        }, args: QueryDataElementContent | undefined, prev: QueryDataElementContent | undefined) => QueryDataElementContent;
+        enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: QueryDataElementContent | undefined, prev: QueryDataElementContent | undefined) => QueryDataElementContent;
         enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
     };
 };
@@ -147,9 +120,4 @@ export declare function enrichmentContent<E extends Enrichment>(e: FlowrSearchEl
 /**
  * Enriches the given search element with the given enrichment type, using the provided analysis data.
  */
-export declare function enrichElement<Element extends FlowrSearchElement<ParentInformation>, E extends Enrichment>(e: Element, s: FlowrSearchElements<ParentInformation>, data: {
-    dataflow: DataflowInformation;
-    normalize: NormalizedAst;
-    cfg: ControlFlowInformation;
-    config: FlowrConfigOptions;
-}, enrichment: E, args?: EnrichmentElementArguments<E>): Promise<Element>;
+export declare function enrichElement<Element extends FlowrSearchElement<ParentInformation>, E extends Enrichment>(e: Element, s: FlowrSearchElements<ParentInformation>, analyzer: ReadonlyFlowrAnalysisProvider, enrichment: E, args?: EnrichmentElementArguments<E>): Promise<Element>;

package/search/search-executor/search-enrichers.js

@@ -5,13 +5,13 @@ exports.enrichmentContent = enrichmentContent;
 exports.enrichElement = enrichElement;
 const objects_1 = require("../../util/objects");
 const vertex_1 = require("../../dataflow/graph/vertex");
-const identify_link_to_last_call_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const assert_1 = require("../../util/assert");
 const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
 const call_context_query_executor_1 = require("../../queries/catalog/call-context-query/call-context-query-executor");
 const cfg_kind_1 = require("../../project/cfg-kind");
+const identify_link_to_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-relation");
 /**
  * An enumeration that stores the names of the available enrichments that can be applied to a set of search elements.
  * See {@link FlowrSearchBuilder.with} for more information on how to apply enrichments.
@@ -29,14 +29,16 @@ var Enrichment;
  */
 exports.Enrichments = {
     [Enrichment.CallTargets]: {
-        enrichElement: (e, _s, data, args, prev) => {
+        enrichElement: async (e, _s, analyzer, args, prev) => {
             // we don't resolve aliases here yet!
             const content = { targets: [] };
-            const callVertex = data.dataflow.graph.getVertex(e.node.info.id);
+            const df = await analyzer.dataflow();
+            const n = await analyzer.normalize();
+            const callVertex = df.graph.getVertex(e.node.info.id);
             if (callVertex?.tag === vertex_1.VertexType.FunctionCall) {
-                const origins = (0, dfg_get_origin_1.getOriginInDfg)(data.dataflow.graph, callVertex.id);
+                const origins = (0, dfg_get_origin_1.getOriginInDfg)(df.graph, callVertex.id);
                 if (!origins || origins.length === 0) {
-                    content.targets = [(0, node_id_1.recoverName)(callVertex.id, data.normalize.idMap)];
+                    content.targets = [(0, node_id_1.recoverName)(callVertex.id, n.idMap)];
                 }
                 else {
                     // find call targets in user code (which have ids!)
@@ -44,7 +46,7 @@ exports.Enrichments = {
                         switch (o.type) {
                             case 2 /* OriginType.FunctionCallOrigin */:
                                 return {
-                                    node: data.normalize.idMap.get(o.id),
+                                    node: n.idMap.get(o.id),
                                 };
                             case 3 /* OriginType.BuiltInFunctionOrigin */:
                                 return o.fn.name;
@@ -53,7 +55,7 @@ exports.Enrichments = {
                         }
                     }).filter(assert_1.isNotUndefined));
                     if (content.targets.length === 0) {
-                        content.targets = [(0, node_id_1.recoverName)(callVertex.id, data.normalize.idMap)];
+                        content.targets = [(0, node_id_1.recoverName)(callVertex.id, n.idMap)];
                     }
                 }
             }
@@ -70,19 +72,21 @@ exports.Enrichments = {
         mapper: ({ targets }) => targets.map(t => t).filter(t => t.node !== undefined)
     },
     [Enrichment.LastCall]: {
-        enrichElement: (e, _s, data, args, prev) => {
+        enrichElement: async (e, _s, analyzer, args, prev) => {
             (0, assert_1.guard)(args && args.length, `${Enrichment.LastCall} enrichment requires at least one argument`);
             const content = prev ?? { linkedIds: [] };
-            const vertex = data.dataflow.graph.get(e.node.info.id);
+            const df = await analyzer.dataflow();
+            const n = await analyzer.normalize();
+            const vertex = df.graph.get(e.node.info.id);
             if (vertex !== undefined && vertex[0].tag === vertex_1.VertexType.FunctionCall) {
                 for (const arg of args) {
-                    const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, data.cfg.graph, data.dataflow.graph, {
+                    const lastCalls = await (0, identify_link_to_relation_1.identifyLinkToRelation)(vertex[0].id, analyzer, {
                         ...arg,
                         callName: (0, call_context_query_executor_1.promoteCallName)(arg.callName),
                         type: 'link-to-last-call',
                     });
                     for (const lastCall of lastCalls) {
-                        content.linkedIds.push({ node: data.normalize.idMap.get(lastCall) });
+                        content.linkedIds.push({ node: n.idMap.get(lastCall) });
                     }
                 }
             }
@@ -138,14 +142,14 @@ function enrichmentContent(e, enrichment) {
 /**
  * Enriches the given search element with the given enrichment type, using the provided analysis data.
  */
-async function enrichElement(e, s, data, enrichment, args) {
+async function enrichElement(e, s, analyzer, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
     const prev = e?.enrichments;
     return {
         ...e,
         enrichments: {
             ...prev ?? {},
-            [enrichment]: await enrichmentData.enrichElement?.(e, s, data, args, prev?.[enrichment])
+            [enrichment]: await enrichmentData.enrichElement?.(e, s, analyzer, args, prev?.[enrichment])
         }
     };
 }