@eagleoutice/flowr 2.4.8 → 2.6.0

package/queries/query.js

@@ -53,7 +53,7 @@ exports.SupportedQueries = {
     'origin': origin_query_format_1.OriginQueryDefinition,
     'linter': linter_query_format_1.LinterQueryDefinition
 };
-function executeQueriesOfSameType(data, queries) {
+async function executeQueriesOfSameType(data, queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');
     /* every query must have the same type */
     (0, assert_1.guard)(queries.every(q => q.type === queries[0].type), 'All queries must have the same type');

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeSitterExecutor = exports.DEFAULT_TREE_SITTER_WASM_PATH = exports.DEFAULT_TREE_SITTER_R_WASM_PATH = void 0;
 const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
-const fs_1 = __importDefault(require("fs"));
 const log_1 = require("../../../util/log");
+const fs_1 = __importDefault(require("fs"));
 exports.DEFAULT_TREE_SITTER_R_WASM_PATH = './node_modules/@eagleoutice/tree-sitter-r/tree-sitter-r.wasm';
 exports.DEFAULT_TREE_SITTER_WASM_PATH = './node_modules/web-tree-sitter/tree-sitter.wasm';
 const wasmLog = log_1.log.getSubLogger({ name: 'tree-sitter-wasm' });

package/r-bridge/retriever.d.ts

@@ -2,16 +2,24 @@ import { type RShell } from './shell';
 import type { AsyncOrSync } from 'ts-essentials';
 import { RShellExecutor } from './shell-executor';
 import type { NormalizedAst } from './lang-4.x/ast/model/processing/decorate';
+import type { SupportedFormats } from '../util/formats/adapter-format';
 export declare const fileProtocol = "file://";
-export interface RParseRequestFromFile {
+export interface ParseRequestAdditionalInfoBase {
+    type: SupportedFormats;
+}
+export interface RParseRequestFromFile<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
     readonly request: 'file';
     /**
      * The path to the file (an absolute path is probably best here).
      * See {@link RParseRequests} for multiple files.
      */
     readonly content: string;
+    /**
+     * Additional info from different file formates like .Rmd
+     */
+    readonly info?: AdditionalInfo;
 }
-export interface RParseRequestFromText {
+export interface RParseRequestFromText<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
     readonly request: 'text';
     /**
      * Source code to parse (not a file path).
@@ -20,6 +28,10 @@ export interface RParseRequestFromText {
      * or concatenate their contents to pass them with this request.
      */
     readonly content: string;
+    /**
+     * Additional info from different file formates like .Rmd
+     */
+    readonly info?: AdditionalInfo;
 }
 /**
  * A provider for an {@link RParseRequests} that can be used, for example, to override source file parsing behavior in tests
@@ -34,6 +46,7 @@ export type RParseRequest = RParseRequestFromFile | RParseRequestFromText;
  * Several requests that can be passed along to {@link retrieveParseDataFromRCode}.
  */
 export type RParseRequests = RParseRequest | ReadonlyArray<RParseRequest>;
+export declare function isParseRequest(request: unknown): request is RParseRequest;
 export declare function requestFromInput(input: `${typeof fileProtocol}${string}`): RParseRequestFromFile;
 export declare function requestFromInput(input: `${typeof fileProtocol}${string}`[]): RParseRequestFromFile[];
 export declare function requestFromInput(input: string): RParseRequestFromText;

package/r-bridge/retriever.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileProtocol = void 0;
+exports.isParseRequest = isParseRequest;
 exports.requestFromInput = requestFromInput;
 exports.requestProviderFromFile = requestProviderFromFile;
 exports.requestProviderFromText = requestProviderFromText;
@@ -22,23 +23,32 @@ const decorate_1 = require("./lang-4.x/ast/model/processing/decorate");
 const type_1 = require("./lang-4.x/ast/model/type");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const adapter_1 = require("../util/formats/adapter");
 exports.fileProtocol = 'file://';
+function isParseRequest(request) {
+    if (typeof request !== 'object' || request === null) {
+        return false;
+    }
+    return 'request' in request;
+}
 /**
  * Creates a {@link RParseRequests} from a given input.
  * If your input starts with {@link fileProtocol}, it is assumed to be a file path and will be processed as such.
  * Giving an array, you can mix file paths and text content (again using the {@link fileProtocol}).
  *
  */
-function requestFromInput(input) {
+function requestFromInput(input, fileTypeHint) {
     if (Array.isArray(input)) {
         return input.flatMap(requestFromInput);
     }
     const content = input;
     const file = content.startsWith(exports.fileProtocol);
-    return {
-        request: file ? 'file' : 'text',
-        content: file ? content.slice(7) : content
-    };
+    if (file) {
+        return (0, adapter_1.requestFromFile)(content.slice(7));
+    }
+    else {
+        return (0, adapter_1.requestFromText)(content, fileTypeHint);
+    }
 }
 function requestProviderFromFile() {
     return {

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

@@ -1,9 +1,7 @@
 import type { FlowrSearch, FlowrSearchLike, SearchOutput } from './flowr-search-builder';
-import type { FlowrSearchInput } from './flowr-search';
-import type { Pipeline } from '../core/steps/pipeline/pipeline';
-type GetSearchElements<S> = S extends FlowrSearch<infer _, infer _, infer _, infer Elements> ? Elements : never;
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+export type GetSearchElements<S> = S extends FlowrSearch<infer _, infer _, infer _, infer Elements> ? Elements : never;
 /**
  * Run a search with the given search query and data.
  */
-export declare function runSearch<S extends FlowrSearchLike, P extends Pipeline>(search: S, data: FlowrSearchInput<P>): GetSearchElements<SearchOutput<S>>;
-export {};
+export declare function runSearch<S extends FlowrSearchLike>(search: S, input: FlowrAnalysisProvider): Promise<GetSearchElements<SearchOutput<S>>>;

package/search/flowr-search-executor.js

@@ -7,10 +7,12 @@ const search_transformer_1 = require("./search-executor/search-transformer");
 /**
  * Run a search with the given search query and data.
  */
-function runSearch(search, data) {
+async function runSearch(search, input) {
     const s = (0, flowr_search_builder_1.getFlowrSearch)(search);
-    return s.search.reduce((acc, transformer) => (0, search_transformer_1.getTransformer)(transformer.name)(data, acc, transformer.args), 
-    /* support multiple arguments may be abstracted away in search frontend */
-    (0, search_generators_1.getGenerator)(s.generator.name)(data, s.generator.args));
+    let acc = await (0, search_generators_1.getGenerator)(s.generator.name)(input, s.generator.args);
+    for (const transformer of s.search) {
+        acc = await (0, search_transformer_1.getTransformer)(transformer.name)(input, acc, transformer.args);
+    }
+    return acc;
 }
 //# sourceMappingURL=flowr-search-executor.js.map

package/search/flowr-search-filters.d.ts

@@ -1,10 +1,10 @@
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import { VertexType } from '../dataflow/graph/vertex';
 import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { FlowrSearchElement, FlowrSearchInput } from './flowr-search';
+import type { FlowrSearchElement } from './flowr-search';
 import type { Enrichment } from './search-executor/search-enrichers';
 import type { BuiltInMappingName } from '../dataflow/environments/built-in';
-import type { Pipeline } from '../core/steps/pipeline/pipeline';
+import type { DataflowInformation } from '../dataflow/info';
 export type FlowrFilterName = keyof typeof FlowrFilters;
 interface FlowrFilterWithArgs<Filter extends FlowrFilterName, Args extends FlowrFilterArgs<Filter>> {
     name: Filter;
@@ -28,7 +28,9 @@ export declare enum FlowrFilter {
      */
     OriginKind = "origin-kind"
 }
-export type FlowrFilterFunction<T> = (e: FlowrSearchElement<ParentInformation>, args: T, data: FlowrSearchInput<Pipeline>) => boolean;
+export type FlowrFilterFunction<T> = (e: FlowrSearchElement<ParentInformation>, args: T, data: {
+    dataflow: DataflowInformation;
+}) => boolean;
 export declare const ValidFlowrFilters: Set<string>;
 export declare const ValidFlowrFiltersReverse: {
     [k: string]: string;
@@ -36,7 +38,9 @@ export declare const ValidFlowrFiltersReverse: {
 export declare const FlowrFilters: {
     readonly "drop-empty-arguments": (e: FlowrSearchElement<ParentInformation>, _args: never) => boolean;
     readonly "matches-enrichment": (e: FlowrSearchElement<ParentInformation>, args: MatchesEnrichmentArgs<Enrichment>) => boolean;
-    readonly "origin-kind": (e: FlowrSearchElement<ParentInformation>, args: OriginKindArgs, data: FlowrSearchInput<Pipeline>) => boolean;
+    readonly "origin-kind": (e: FlowrSearchElement<ParentInformation>, args: OriginKindArgs, data: {
+        dataflow: DataflowInformation;
+    }) => boolean;
 };
 export type FlowrFilterArgs<F extends FlowrFilter> = typeof FlowrFilters[F] extends FlowrFilterFunction<infer Args> ? Args : never;
 export interface MatchesEnrichmentArgs<E extends Enrichment> {
@@ -48,7 +52,7 @@ export interface OriginKindArgs {
     matchType?: 'some' | 'every';
     keepNonFunctionCalls?: boolean;
 }
-export declare function testFunctionsIgnoringPackage(functions: string[]): RegExp;
+export declare function testFunctionsIgnoringPackage(functions: readonly string[]): RegExp;
 type ValidFilterTypes<F extends FlowrFilter = FlowrFilter> = FlowrFilterName | FlowrFilterWithArgs<F, FlowrFilterArgs<F>> | RType | VertexType;
 /**
  * By default, we provide filter for every {@link RType} and {@link VertexType}.
@@ -102,7 +106,9 @@ export declare function isBinaryTree(tree: unknown): tree is {
 };
 interface FilterData {
     readonly element: FlowrSearchElement<ParentInformation>;
-    readonly data: FlowrSearchInput<Pipeline>;
+    readonly data: {
+        dataflow: DataflowInformation;
+    };
 }
 export declare function evalFilter<Filter extends FlowrFilter>(filter: FlowrFilterExpression<Filter>, data: FilterData): boolean;
 export {};

package/search/flowr-search-filters.js

@@ -156,7 +156,7 @@ const evalVisit = {
     xor: ({ left, right }, data) => evalTree(left, data) !== evalTree(right, data),
     not: ({ operand }, data) => !evalTree(operand, data),
     'r-type': ({ value }, { element }) => element.node.type === value,
-    'vertex-type': ({ value }, { data: { dataflow }, element }) => dataflow.graph.getVertex(element.node.info.id)?.tag === value,
+    'vertex-type': ({ value }, { data, element }) => data.dataflow.graph.getVertex(element.node.info.id)?.tag === value,
     'special': ({ value }, { data, element }) => {
         const name = typeof value === 'string' ? value : value.name;
         const args = typeof value === 'string' ? undefined : value.args;

package/search/flowr-search.d.ts

@@ -1,10 +1,7 @@
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
-import type { Pipeline, PipelineOutput, PipelineStepOutputWithName } from '../core/steps/pipeline/pipeline';
-import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataflowInformation } from '../dataflow/info';
-import type { FlowrConfigOptions } from '../config';
-import type { Enrichment, EnrichmentSearchArguments, EnrichmentElementContent, EnrichmentSearchContent } from './search-executor/search-enrichers';
+import type { Enrichment, EnrichmentElementContent, EnrichmentSearchArguments, EnrichmentSearchContent } from './search-executor/search-enrichers';
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
 /**
  * Yes, for now we do technically not need a wrapper around the RNode, but this allows us to attach caches etc.
  * just for the respective search.
@@ -45,13 +42,6 @@ export interface FlowrSearchGetFilter extends Record<string, unknown> {
      */
     readonly id?: NodeId;
 }
-type MinimumInputForFlowrSearch<P extends Pipeline> = PipelineStepOutputWithName<P, 'normalize'> extends NormalizedAst ? (PipelineStepOutputWithName<P, 'dataflow'> extends DataflowInformation ? PipelineOutput<P> & {
-    normalize: NormalizedAst;
-    dataflow: DataflowInformation;
-    config: FlowrConfigOptions;
-} : never) : never;
-/** we allow any pipeline, which provides us with a 'normalize' and 'dataflow' step */
-export type FlowrSearchInput<P extends Pipeline> = MinimumInputForFlowrSearch<P>;
 /** Intentionally, we abstract away from an array to avoid the use of conventional typescript operations */
 export declare class FlowrSearchElements<Info = NoInfo, Elements extends FlowrSearchElement<Info>[] = FlowrSearchElement<Info>[]> {
     private elements;
@@ -60,14 +50,13 @@ export declare class FlowrSearchElements<Info = NoInfo, Elements extends FlowrSe
     add(element: FlowrSearchElement<Info>): this;
     addAll(elements: FlowrSearchElement<Info>[]): this;
     getElements(): Readonly<Elements>;
-    mutate<OutElements extends Elements>(mutator: (elements: Elements) => OutElements): this;
+    mutate<OutElements extends Elements>(mutator: (elements: Elements) => OutElements | Promise<OutElements>): this | Promise<this>;
     /**
      * Enriches this flowr search element collection with the given enrichment.
      * To retrieve enrichment content for a given enrichment type, use {@link enrichmentContent}.
      *
-     * Please note that this function does not also enrich individual elements, which is done through {@link enrichElement}. Both functions are called in a consise manner in {@link FlowrSearchBuilder.with}, which is the preferred way to add enrichments to a search.
+     * Please note that this function does not also enrich individual elements, which is done through {@link enrichElement}. Both functions are called in a concise manner in {@link FlowrSearchBuilder.with}, which is the preferred way to add enrichments to a search.
      */
-    enrich<E extends Enrichment>(data: FlowrSearchInput<Pipeline>, enrichment: E, args?: EnrichmentSearchArguments<E>): this;
+    enrich<E extends Enrichment>(data: FlowrAnalysisProvider, enrichment: E, args?: EnrichmentSearchArguments<E>): Promise<this>;
     enrichmentContent<E extends Enrichment>(enrichment: E): EnrichmentSearchContent<E>;
 }
-export {};

package/search/flowr-search.js

@@ -23,21 +23,30 @@ class FlowrSearchElements {
         return this.elements;
     }
     mutate(mutator) {
-        this.elements = mutator(this.elements);
-        return this;
+        const result = mutator(this.elements);
+        if (result instanceof Promise) {
+            return result.then(resolvedElements => {
+                this.elements = resolvedElements;
+                return this;
+            });
+        }
+        else {
+            this.elements = result;
+            return this;
+        }
     }
     /**
      * Enriches this flowr search element collection with the given enrichment.
      * To retrieve enrichment content for a given enrichment type, use {@link enrichmentContent}.
      *
-     * Please note that this function does not also enrich individual elements, which is done through {@link enrichElement}. Both functions are called in a consise manner in {@link FlowrSearchBuilder.with}, which is the preferred way to add enrichments to a search.
+     * Please note that this function does not also enrich individual elements, which is done through {@link enrichElement}. Both functions are called in a concise manner in {@link FlowrSearchBuilder.with}, which is the preferred way to add enrichments to a search.
      */
-    enrich(data, enrichment, args) {
+    async enrich(data, enrichment, args) {
         const enrichmentData = search_enrichers_1.Enrichments[enrichment];
         if (enrichmentData.enrichSearch !== undefined) {
             this.enrichments = {
                 ...this.enrichments ?? {},
-                [enrichment]: enrichmentData.enrichSearch(this, data, args, this.enrichments?.[enrichment])
+                [enrichment]: await enrichmentData.enrichSearch(this, data, args, this.enrichments?.[enrichment])
             };
         }
         return this;

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

@@ -1,20 +1,25 @@
-import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchInput } from '../flowr-search';
-import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { FlowrSearchElement, FlowrSearchElements } from '../flowr-search';
+import type { NormalizedAst, 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';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
-import type { QueryResult, SynchronousQuery } from '../../queries/query';
+import type { Query, QueryResult } from '../../queries/query';
 import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
-import type { AsyncOrSyncType } from 'ts-essentials';
+import type { AsyncOrSync } from 'ts-essentials';
+import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import type { DataflowInformation } from '../../dataflow/info';
 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: FlowrSearchInput<Pipeline>, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => ElementContent;
-    readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: FlowrSearchInput<Pipeline>, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => SearchContent;
+    readonly enrichElement?: (element: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation>, data: {
+        dataflow: DataflowInformation;
+        normalize: NormalizedAst;
+        cfg: ControlFlowInformation;
+    }, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => AsyncOrSync<ElementContent>;
+    readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: FlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
     /**
      * The mapping function used by the {@link Mapper.Enrichment} mapper.
      */
@@ -76,11 +81,11 @@ export interface CfgInformationArguments extends MergeableRecord {
 }
 export interface QueryDataElementContent extends MergeableRecord {
     /** The name of the query that this element originated from. To get each query's data, see {@link QueryDataSearchContent}. */
-    query: SynchronousQuery['type'];
+    query: Query['type'];
 }
 export interface QueryDataSearchContent extends MergeableRecord {
     queries: {
-        [QueryType in SynchronousQuery['type']]: AsyncOrSyncType<QueryResult<QueryType>>;
+        [QueryType in Query['type']]: Awaited<QueryResult<QueryType>>;
     };
 }
 /**
@@ -89,49 +94,41 @@ export interface QueryDataSearchContent extends MergeableRecord {
  */
 export declare const Enrichments: {
     readonly "call-targets": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: {
+            dataflow: DataflowInformation;
+            normalize: NormalizedAst;
+            cfg: ControlFlowInformation;
         }, args: {
             onlyBuiltin?: boolean;
         } | undefined, prev: CallTargetsContent | undefined) => CallTargetsContent;
         mapper: ({ targets }: CallTargetsContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "last-call": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, _s: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: {
+            dataflow: DataflowInformation;
+            normalize: NormalizedAst;
+            cfg: ControlFlowInformation;
         }, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "cfg-information": {
-        enrichElement: (e: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
+        enrichElement: (e: FlowrSearchElement<ParentInformation>, search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
+            dataflow: DataflowInformation;
+            normalize: NormalizedAst;
+            cfg: ControlFlowInformation;
         }, _args: CfgInformationArguments | undefined, prev: CfgInformationElementContent | undefined) => {
             isRoot: boolean;
             isReachable: boolean | undefined;
         };
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
-        }, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => CfgInformationSearchContent;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: FlowrAnalysisProvider, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
     };
     readonly "query-data": {
-        enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
+        enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
+            dataflow: DataflowInformation;
+            normalize: NormalizedAst;
+            cfg: ControlFlowInformation;
         }, args: QueryDataElementContent | undefined, prev: QueryDataElementContent | undefined) => QueryDataElementContent;
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: import("../../core/steps/pipeline/pipeline").PipelineOutput<Pipeline<import("../../core/steps/pipeline-step").IPipelineStep<import("../../core/steps/pipeline-step").PipelineStepName, (...args: any[]) => any>>> & {
-            normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-            dataflow: import("../../dataflow/info").DataflowInformation;
-            config: import("../../config").FlowrConfigOptions;
-        }, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: FlowrAnalysisProvider, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
     };
 };
 /**
@@ -141,4 +138,8 @@ export declare const Enrichments: {
  * @param enrichment - The enrichment content, if present, else `undefined`.
  */
 export declare function enrichmentContent<E extends Enrichment>(e: FlowrSearchElement<ParentInformation>, enrichment: E): EnrichmentElementContent<E>;
-export declare function enrichElement<Element extends FlowrSearchElement<ParentInformation>, E extends Enrichment>(e: Element, s: FlowrSearchElements<ParentInformation>, data: FlowrSearchInput<Pipeline>, enrichment: E, args?: EnrichmentElementArguments<E>): Element;
+export declare function enrichElement<Element extends FlowrSearchElement<ParentInformation>, E extends Enrichment>(e: Element, s: FlowrSearchElements<ParentInformation>, data: {
+    dataflow: DataflowInformation;
+    normalize: NormalizedAst;
+    cfg: ControlFlowInformation;
+}, enrichment: E, args?: EnrichmentElementArguments<E>): Promise<Element>;

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

@@ -100,7 +100,7 @@ exports.Enrichments = {
                 isReachable: searchContent.reachableNodes?.has(e.node.info.id)
             };
         },
-        enrichSearch: (_search, data, args, prev) => {
+        enrichSearch: async (_search, data, args, prev) => {
             args = {
                 forceRefresh: false,
                 checkReachable: false,
@@ -113,7 +113,7 @@ exports.Enrichments = {
             }
             const content = {
                 ...prev,
-                cfg: (0, extract_cfg_1.extractCfg)(data.normalize, data.config, data.dataflow.graph, args.simplificationPasses),
+                cfg: await data.controlflow(args.simplificationPasses, true),
             };
             if (args.checkReachable) {
                 content.reachableNodes = (0, cfg_simplification_1.cfgFindAllReachable)(content.cfg);
@@ -136,14 +136,14 @@ exports.Enrichments = {
 function enrichmentContent(e, enrichment) {
     return e?.enrichments?.[enrichment];
 }
-function enrichElement(e, s, data, enrichment, args) {
+async function enrichElement(e, s, data, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
     const prev = e?.enrichments;
     return {
         ...e,
         enrichments: {
             ...prev ?? {},
-            [enrichment]: enrichmentData.enrichElement?.(e, s, data, args, prev?.[enrichment])
+            [enrichment]: await enrichmentData.enrichElement?.(e, s, data, args, prev?.[enrichment])
         }
     };
 }

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

@@ -1,10 +1,10 @@
-import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } from '../flowr-search';
+import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter } from '../flowr-search';
 import { FlowrSearchElements } from '../flowr-search';
-import type { Pipeline } from '../../core/steps/pipeline/pipeline';
 import type { TailTypesOrUndefined } from '../../util/collections/arrays';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../../slicing/criterion/parse';
-import type { SynchronousQuery } from '../../queries/query';
+import type { Query } from '../../queries/query';
+import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
 /**
  * This is a union of all possible generator node types
  */
@@ -25,18 +25,18 @@ export declare const generators: {
     readonly from: typeof generateFrom;
     readonly 'from-query': typeof generateFromQuery;
 };
-declare function generateAll(data: FlowrSearchInput<Pipeline>): FlowrSearchElements<ParentInformation>;
-declare function generateGet(data: FlowrSearchInput<Pipeline>, { filter: { line, column, id, name, nameIsRegex } }: {
+declare function generateAll(data: FlowrAnalysisProvider): Promise<FlowrSearchElements<ParentInformation>>;
+declare function generateGet(input: FlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex } }: {
     filter: FlowrSearchGetFilter;
-}): FlowrSearchElements<ParentInformation>;
-declare function generateFrom(data: FlowrSearchInput<Pipeline>, args: {
+}): Promise<FlowrSearchElements<ParentInformation>>;
+declare function generateFrom(_input: FlowrAnalysisProvider, args: {
     from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[];
 }): FlowrSearchElements<ParentInformation>;
-declare function generateFromQuery(data: FlowrSearchInput<Pipeline>, args: {
-    from: readonly SynchronousQuery[];
-}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
-declare function generateCriterion(data: FlowrSearchInput<Pipeline>, args: {
+declare function generateFromQuery(input: FlowrAnalysisProvider, args: {
+    from: readonly Query[];
+}): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+declare function generateCriterion(input: FlowrAnalysisProvider, args: {
     criterion: SlicingCriteria;
-}): FlowrSearchElements<ParentInformation>;
+}): Promise<FlowrSearchElements<ParentInformation>>;
 export declare function getGenerator<Name extends GeneratorNames>(name: Name): typeof generators[Name];
 export {};

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

@@ -17,21 +17,23 @@ exports.generators = {
     from: generateFrom,
     'from-query': generateFromQuery
 };
-function generateAll(data) {
-    return new flowr_search_1.FlowrSearchElements(getAllNodes(data)
+async function generateAll(data) {
+    return new flowr_search_1.FlowrSearchElements((await getAllNodes(data))
         .map(node => ({ node })));
 }
-function getAllNodes(data) {
-    return [...new Map([...data.normalize.idMap.values()].map(n => [n.info.id, n]))
+async function getAllNodes(data) {
+    const normalize = await data.normalize();
+    return [...new Map([...normalize.idMap.values()].map(n => [n.info.id, n]))
             .values()];
 }
-function generateGet(data, { filter: { line, column, id, name, nameIsRegex } }) {
+async function generateGet(input, { filter: { line, column, id, name, nameIsRegex } }) {
+    const normalize = await input.normalize();
     let potentials = (id ?
-        [data.normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
-        getAllNodes(data));
+        [normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
+        await getAllNodes(input));
     if (line && line < 0) {
-        const maxLines = data.normalize.ast.info.fullRange?.[2] ??
-            (id ? getAllNodes(data) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
+        const maxLines = normalize.ast.info.fullRange?.[2] ??
+            (id ? (await getAllNodes(input)) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
         line = maxLines + line + 1;
     }
     if (line && column) {
@@ -52,11 +54,11 @@ function generateGet(data, { filter: { line, column, id, name, nameIsRegex } })
     }
     return new flowr_search_1.FlowrSearchElements(potentials.map(node => ({ node })));
 }
-function generateFrom(data, args) {
+function generateFrom(_input, args) {
     return new flowr_search_1.FlowrSearchElements(Array.isArray(args.from) ? args.from : [args.from]);
 }
-function generateFromQuery(data, args) {
-    const result = (0, query_1.executeQueries)({ ast: data.normalize, dataflow: data.dataflow, config: data.config }, args.from);
+async function generateFromQuery(input, args) {
+    const result = await (0, query_1.executeQueries)({ analyzer: input }, args.from);
     // collect involved nodes
     const nodesByQuery = new Map();
     for (const [query, content] of Object.entries(result)) {
@@ -66,19 +68,25 @@ function generateFromQuery(data, args) {
         const nodes = new Set();
         const queryDef = query_1.SupportedQueries[query];
         for (const node of queryDef.flattenInvolvedNodes(content, args.from)) {
-            nodes.add({ node: data.normalize.idMap.get(node) });
+            nodes.add({ node: (await input.normalize()).idMap.get(node) });
         }
         nodesByQuery.set(query, nodes);
     }
     // enrich elements with query data
-    const elements = new flowr_search_1.FlowrSearchElements([...nodesByQuery].flatMap(([_, nodes]) => [...nodes])).enrich(data, search_enrichers_1.Enrichment.QueryData, { queries: result });
-    return elements.mutate(s => s.map(e => {
+    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]))
+        .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 (0, search_enrichers_1.enrichElement)(e, elements, data, search_enrichers_1.Enrichment.QueryData, { query });
-    }));
+        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg }, search_enrichers_1.Enrichment.QueryData, { query });
+    })));
 }
-function generateCriterion(data, args) {
-    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: data.normalize.idMap.get((0, parse_1.slicingCriterionToId)(c, data.normalize.idMap)) })));
+async function generateCriterion(input, args) {
+    const idMap = (await input.normalize()).idMap;
+    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: idMap.get((0, parse_1.slicingCriterionToId)(c, idMap)) })));
 }
 function getGenerator(name) {
     if (!exports.generators[name]) {

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

@@ -1,19 +1,19 @@
-import type { FlowrSearchElement, FlowrSearchInput } from '../flowr-search';
+import type { FlowrSearchElement } from '../flowr-search';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { Enrichment } from './search-enrichers';
 import type { MergeableRecord } from '../../util/objects';
-import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export declare enum Mapper {
     Enrichment = "enrichment"
 }
 export interface MapperData<Arguments extends string | MergeableRecord> {
-    mapper: (e: FlowrSearchElement<ParentInformation>, data: FlowrSearchInput<Pipeline>, args: Arguments) => FlowrSearchElement<ParentInformation>[];
+    mapper: (e: FlowrSearchElement<ParentInformation>, data: FlowrAnalysisProvider, args: Arguments) => FlowrSearchElement<ParentInformation>[];
 }
 export type MapperArguments<M extends Mapper> = typeof Mappers[M] extends MapperData<infer Arguments> ? Arguments : never;
 declare const Mappers: {
     readonly enrichment: {
-        mapper: (e: FlowrSearchElement<ParentInformation>, _data: FlowrSearchInput<Pipeline>, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
+        mapper: (e: FlowrSearchElement<ParentInformation>, _data: FlowrAnalysisProvider, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
     };
 };
-export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: FlowrSearchInput<Pipeline>, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
+export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: FlowrAnalysisProvider, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
 export {};