@eagleoutice/flowr 2.8.11 → 2.8.13

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])
         }
     };
 }

package/search/search-executor/search-generators.js

@@ -82,15 +82,13 @@ async function generateFromQuery(input, args) {
         nodesByQuery.set(query, nodes);
     }
     // enrich elements with query data
-    const normalize = await input.normalize();
-    const dataflow = await input.dataflow();
-    const cfg = await input.controlflow();
-    const elements = await new flowr_search_1.FlowrSearchElements([...nodesByQuery]
-        .flatMap(([_, nodes]) => [...nodes]))
+    const nodearr = [...nodesByQuery];
+    const elements = await new flowr_search_1.FlowrSearchElements(nodearr
+        .flatMap(([_, nodes]) => Array.from(nodes)))
         .enrich(input, search_enrichers_1.Enrichment.QueryData, { queries: result });
     return elements.mutate(s => Promise.all(s.map(async (e) => {
-        const [query, _] = [...nodesByQuery].find(([_, nodes]) => nodes.has(e));
-        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg, config: input.flowrConfig }, search_enrichers_1.Enrichment.QueryData, { query });
+        const [query, _] = nodearr.find(([_, nodes]) => nodes.has(e));
+        return await (0, search_enrichers_1.enrichElement)(e, elements, input, search_enrichers_1.Enrichment.QueryData, { query });
     })));
 }
 async function generateSyntax(input, args) {

package/search/search-executor/search-transformer.js

@@ -100,13 +100,7 @@ async function getFilter(data, elements, { filter }) {
     return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, data: { dataflow } })));
 }
 async function getWith(input, elements, { info, args }) {
-    const data = {
-        normalize: await input.normalize(),
-        dataflow: await input.dataflow(),
-        cfg: await input.controlflow(),
-        config: input.flowrConfig
-    };
-    return (await elements.enrich(input, info, args)).mutate(async (s) => await Promise.all(s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, data, info, args))));
+    return (await elements.enrich(input, info, args)).mutate(async (s) => await Promise.all(s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, input, info, args))));
 }
 function getMap(data, elements, { mapper, args }) {
     return elements.mutate(elements => elements.flatMap(e => (0, search_mappers_1.map)(e, data, mapper, args)));

package/util/schema.js

@@ -24,7 +24,7 @@ function genericDescription(level, formatter, name, desc) {
     }
     const lines = [...headerLine(level, formatter, name, desc.type ?? 'unknown', desc.flags)];
     if ('allow' in desc) {
-        lines.push({ level: level + 1, text: `Allows only the values: ${desc['allow'].map(v => "'" + v + "'").join(', ')}` });
+        lines.push({ level: level + 1, text: `Only allows: ${desc['allow'].map(v => "'" + v + "'").join(', ')}` });
     }
     switch (desc.type) {
         case 'object':
@@ -57,18 +57,16 @@ function printFlags(flags) {
     if ('presence' in flags) {
         flagText += String(flags['presence']);
     }
-    return flagText.trim().length > 0 ? '[' + flagText + ']' : '';
+    return flagText.trim().length > 0 ? '[' + flagText + '] ' : '';
 }
 /**
  * Creates the header line(s) for a schema description.
  */
 function headerLine(level, formatter, name, type, flags) {
-    const text = `- ${(0, ansi_1.bold)(name, formatter)} ${formatter.format(type, { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ })} ${printFlags(flags)}`;
-    const baseLine = { level, text };
-    if (flags && 'description' in flags) {
-        return [baseLine, { level: level + 1, text: (0, ansi_1.italic)(flags['description'], formatter) }];
-    }
-    return [baseLine];
+    const fnam = name === '.' ? '' : (0, ansi_1.bold)(name, formatter) + ' ';
+    const fdesc = flags && 'description' in flags ? (0, ansi_1.italic)(flags['description'], formatter) + ' ' : '';
+    const text = `- ${fnam}${printFlags(flags)}${fdesc}(${formatter.format(type, { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ })})`;
+    return [{ level, text }];
 }
 /**
  * Describes a Joi object schema.

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.8.11';
+const version = '2.8.13';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */