@eagleoutice/flowr 2.2.16 → 2.4.0

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

@@ -1,7 +1,7 @@
 import type { FlowrSearch, FlowrSearchLike, SearchOutput } from './flowr-search-builder';
-import type { FlowrSearchElements, FlowrSearchInput } from './flowr-search';
+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 extends FlowrSearchElements<infer _, infer E> ? E : never : never;
+type GetSearchElements<S> = S extends FlowrSearch<infer _, infer _, infer _, infer Elements> ? Elements : never;
 /**
  * Run a search with the given search query and data.
  */

package/search/flowr-search-executor.js

@@ -11,6 +11,6 @@ function runSearch(search, data) {
     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)).getElements();
+    (0, search_generators_1.getGenerator)(s.generator.name)(data, s.generator.args));
 }
 //# sourceMappingURL=flowr-search-executor.js.map

package/search/flowr-search.d.ts

@@ -3,22 +3,18 @@ import type { Pipeline, PipelineOutput, PipelineStepOutputWithName } from '../co
 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 { BaseQueryResult } from '../queries/base-query-format';
-import type { Query } from '../queries/query';
 import type { FlowrConfigOptions } from '../config';
-import type { MarkOptional } from 'ts-essentials';
+import type { Enrichment, EnrichmentSearchArguments, EnrichmentElementContent, EnrichmentSearchContent } from './search-executor/search-enrichers';
 /**
  * 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.
  */
 export interface FlowrSearchElement<Info> {
     readonly node: RNode<Info>;
+    readonly enrichments?: {
+        [E in Enrichment]?: EnrichmentElementContent<E>;
+    };
 }
-export interface FlowrSearchElementFromQuery<Info> extends FlowrSearchElement<Info> {
-    readonly query: Query['type'];
-    readonly queryResult: BaseQueryResult;
-}
-export type FlowrSearchElementMaybeFromQuery<Info> = MarkOptional<FlowrSearchElementFromQuery<Info>, 'query' | 'queryResult'>;
 export interface FlowrSearchNodeBase<Type extends string, Name extends string, Args extends Record<string, unknown> | undefined> {
     readonly type: Type;
     readonly name: Name;
@@ -59,10 +55,19 @@ 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;
+    private enrichments;
     constructor(elements?: Elements);
     add(element: FlowrSearchElement<Info>): this;
     addAll(elements: FlowrSearchElement<Info>[]): this;
     getElements(): Readonly<Elements>;
     mutate<OutElements extends Elements>(mutator: (elements: Elements) => OutElements): 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.
+     */
+    enrich<E extends Enrichment>(data: FlowrSearchInput<Pipeline>, enrichment: E, args?: EnrichmentSearchArguments<E>): this;
+    enrichmentContent<E extends Enrichment>(enrichment: E): EnrichmentSearchContent<E>;
 }
 export {};

package/search/flowr-search.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrSearchElements = void 0;
+const search_enrichers_1 = require("./search-executor/search-enrichers");
 /** Intentionally, we abstract away from an array to avoid the use of conventional typescript operations */
 class FlowrSearchElements {
     elements = [];
+    enrichments = {};
     constructor(elements) {
         if (elements) {
             this.elements = elements;
@@ -24,6 +26,25 @@ class FlowrSearchElements {
         this.elements = mutator(this.elements);
         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.
+     */
+    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])
+            };
+        }
+        return this;
+    }
+    enrichmentContent(enrichment) {
+        return this.enrichments?.[enrichment];
+    }
 }
 exports.FlowrSearchElements = FlowrSearchElements;
 //# sourceMappingURL=flowr-search.js.map

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

@@ -1,37 +1,38 @@
-import type { FlowrSearchElement, FlowrSearchInput } from '../flowr-search';
+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 { MergeableRecord } from '../../util/objects';
 import type { Identifier } from '../../dataflow/environments/identifier';
 import type { LinkToLastCall } from '../../queries/catalog/call-context-query/call-context-query-format';
-/**
- * A {@link FlowrSearchElement} that is enriched with a set of enrichments through {@link FlowrSearchBuilder.with}.
- * Enrichments can be retrieved easily from an element through {@link enrichmentContent}.
- */
-export interface EnrichedFlowrSearchElement<Info> extends FlowrSearchElement<Info> {
-    enrichments: {
-        [E in Enrichment]?: EnrichmentContent<E>;
-    };
-}
-export interface EnrichmentData<EnrichmentContent extends MergeableRecord, EnrichmentArguments = undefined> {
+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 { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
+import type { AsyncOrSyncType } from 'ts-essentials';
+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 enrich: (e: FlowrSearchElement<ParentInformation>, data: FlowrSearchInput<Pipeline>, args: EnrichmentArguments | undefined, previousValue: EnrichmentContent | undefined) => EnrichmentContent;
+    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;
     /**
      * The mapping function used by the {@link Mapper.Enrichment} mapper.
      */
-    readonly mapper: (c: EnrichmentContent) => FlowrSearchElement<ParentInformation>[];
+    readonly mapper?: (content: ElementContent) => FlowrSearchElement<ParentInformation>[];
 }
-export type EnrichmentContent<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer Content, infer _Args> ? Content : never;
-export type EnrichmentArguments<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer _Content, infer Args> ? Args : never;
+export type EnrichmentElementContent<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer EC, infer _EA, infer _SC, infer _SA> ? EC : never;
+export type EnrichmentElementArguments<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer _EC, infer EA, infer _SC, infer _SA> ? EA : never;
+export type EnrichmentSearchContent<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer _EC, infer _EA, infer SC, infer _SA> ? SC : never;
+export type EnrichmentSearchArguments<E extends Enrichment> = typeof Enrichments[E] extends EnrichmentData<infer _EC, infer _EA, infer _SC, infer SA> ? SA : never;
 /**
  * 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.
  */
 export declare enum Enrichment {
     CallTargets = "call-targets",
-    LastCall = "last-call"
+    LastCall = "last-call",
+    CfgInformation = "cfg-information",
+    QueryData = "query-data"
 }
 export interface CallTargetsContent extends MergeableRecord {
     /**
@@ -43,13 +44,52 @@ export interface CallTargetsContent extends MergeableRecord {
 export interface LastCallContent extends MergeableRecord {
     linkedIds: FlowrSearchElement<ParentInformation>[];
 }
+export interface CfgInformationElementContent extends MergeableRecord {
+    /**
+     * Whether the current node is a root node in the CFG, which is a node that is not contained inside of a function definition.
+     */
+    isRoot: boolean;
+    /**
+     * Whether the current node is reachable from the root of the CFG.
+     * Only has a value if {@link CfgInformationArguments.checkReachable} was true.
+     */
+    isReachable?: boolean;
+}
+export interface CfgInformationSearchContent extends MergeableRecord {
+    /**
+     * The CFG attached to the search, extracted using {@link extractCfg}.
+     */
+    cfg: ControlFlowInformation;
+    /**
+     * The set of all nodes that are reachable from the root of the CFG, extracted using {@link visitCfgInOrder}.
+     * Only has a value if {@link CfgInformationArguments.checkReachable} was true.
+     */
+    reachableNodes?: Set<NodeId>;
+}
+export interface CfgInformationArguments extends MergeableRecord {
+    /** Whether to recalculate the CFG information if it already exists on the current search. Defaults to `false`. */
+    forceRefresh?: boolean;
+    /** The simplification passes that should be run on the extracted CFG. Defaults to the entries of {@link DefaultCfgSimplificationOrder}. */
+    simplificationPasses?: CfgSimplificationPassName[];
+    /** Whether to check nodes for reachability, and subsequently set {@link CfgInformationSearchContent.reachableNodes} and {@link CfgInformationElementContent.isReachable}. Defaults to `false`. */
+    checkReachable?: boolean;
+}
+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'];
+}
+export interface QueryDataSearchContent extends MergeableRecord {
+    queries: {
+        [QueryType in SynchronousQuery['type']]: AsyncOrSyncType<QueryResult<QueryType>>;
+    };
+}
 /**
  * The registry of enrichments that are currently supported by the search.
  * See {@link FlowrSearchBuilder.with} for more information on how to apply enrichments.
  */
 export declare const Enrichments: {
     readonly "call-targets": {
-        enrich: (e: 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>>> & {
+        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;
@@ -59,13 +99,40 @@ export declare const Enrichments: {
         mapper: ({ targets }: CallTargetsContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "last-call": {
-        enrich: (e: 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>>> & {
+        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;
         }, args: Omit<LinkToLastCall<string | RegExp>, "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;
+        }, _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;
+    };
+    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;
+        }, 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>;
+    };
 };
 /**
  * Returns the content of the given enrichment type from a {@link FlowrSearchElement}.
@@ -73,5 +140,5 @@ export declare const Enrichments: {
  * @param e - The search element whose enrichment content should be retrieved.
  * @param enrichment - The enrichment content, if present, else `undefined`.
  */
-export declare function enrichmentContent<E extends Enrichment>(e: FlowrSearchElement<ParentInformation>, enrichment: E): EnrichmentContent<E>;
-export declare function enrich<ElementIn extends FlowrSearchElement<ParentInformation>, ElementOut extends ElementIn & EnrichedFlowrSearchElement<ParentInformation>, ConcreteEnrichment extends Enrichment>(e: ElementIn, data: FlowrSearchInput<Pipeline>, enrichment: ConcreteEnrichment, args?: EnrichmentArguments<ConcreteEnrichment>): ElementOut;
+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;

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

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enrichments = exports.Enrichment = void 0;
 exports.enrichmentContent = enrichmentContent;
-exports.enrich = enrich;
+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 extract_cfg_1 = require("../../control-flow/extract-cfg");
 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");
 /**
  * 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.
@@ -17,6 +19,8 @@ var Enrichment;
 (function (Enrichment) {
     Enrichment["CallTargets"] = "call-targets";
     Enrichment["LastCall"] = "last-call";
+    Enrichment["CfgInformation"] = "cfg-information";
+    Enrichment["QueryData"] = "query-data";
 })(Enrichment || (exports.Enrichment = Enrichment = {}));
 /**
  * The registry of enrichments that are currently supported by the search.
@@ -24,7 +28,7 @@ var Enrichment;
  */
 exports.Enrichments = {
     [Enrichment.CallTargets]: {
-        enrich: (e, data, args, prev) => {
+        enrichElement: (e, _s, data, args, prev) => {
             // we don't resolve aliases here yet!
             const content = { targets: [] };
             const callVertex = data.dataflow.graph.getVertex(e.node.info.id);
@@ -65,7 +69,7 @@ exports.Enrichments = {
         mapper: ({ targets }) => targets.map(t => t).filter(t => t.node !== undefined)
     },
     [Enrichment.LastCall]: {
-        enrich: (e, data, args, prev) => {
+        enrichElement: (e, _s, data, 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);
@@ -86,6 +90,41 @@ exports.Enrichments = {
         },
         mapper: ({ linkedIds }) => linkedIds
     },
+    [Enrichment.CfgInformation]: {
+        enrichElement: (e, search, _data, _args, prev) => {
+            const searchContent = search.enrichmentContent(Enrichment.CfgInformation);
+            return {
+                ...prev,
+                isRoot: searchContent.cfg.graph.rootIds().has(e.node.info.id),
+                isReachable: searchContent.reachableNodes?.has(e.node.info.id)
+            };
+        },
+        enrichSearch: (_search, data, args, prev) => {
+            args = {
+                forceRefresh: false,
+                checkReachable: false,
+                simplificationPasses: cfg_simplification_1.DefaultCfgSimplificationOrder,
+                ...args
+            };
+            // short-circuit if we already have a cfg stored
+            if (!args.forceRefresh && prev?.simpleCfg) {
+                return prev;
+            }
+            const content = {
+                ...prev,
+                cfg: (0, extract_cfg_1.extractCfg)(data.normalize, data.config, data.dataflow.graph, args.simplificationPasses),
+            };
+            if (args.checkReachable) {
+                content.reachableNodes = (0, cfg_simplification_1.cfgFindAllReachable)(content.cfg);
+            }
+            return content;
+        }
+    },
+    [Enrichment.QueryData]: {
+        // the query data enrichment is just a "pass-through" that passes the query data to the underlying search
+        enrichElement: (_e, _search, _data, args, prev) => (args ?? prev),
+        enrichSearch: (_search, _data, args, prev) => (0, objects_1.deepMergeObject)(prev, args)
+    }
 };
 /**
  * Returns the content of the given enrichment type from a {@link FlowrSearchElement}.
@@ -96,14 +135,14 @@ exports.Enrichments = {
 function enrichmentContent(e, enrichment) {
     return e?.enrichments?.[enrichment];
 }
-function enrich(e, data, enrichment, args) {
+function enrichElement(e, s, data, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
     const prev = e?.enrichments;
     return {
         ...e,
         enrichments: {
             ...prev ?? {},
-            [enrichment]: enrichmentData.enrich(e, data, args, prev?.[enrichment])
+            [enrichment]: enrichmentData.enrichElement?.(e, s, data, args, prev?.[enrichment])
         }
     };
 }

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

@@ -1,10 +1,10 @@
-import type { FlowrSearchElement, FlowrSearchElementFromQuery, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } from '../flowr-search';
+import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } 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 { Query } from '../../queries/query';
+import type { SynchronousQuery } from '../../queries/query';
 /**
  * This is a union of all possible generator node types
  */
@@ -33,8 +33,8 @@ declare function generateFrom(data: FlowrSearchInput<Pipeline>, args: {
     from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[];
 }): FlowrSearchElements<ParentInformation>;
 declare function generateFromQuery(data: FlowrSearchInput<Pipeline>, args: {
-    from: readonly Query[];
-}): FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>;
+    from: readonly SynchronousQuery[];
+}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
 declare function generateCriterion(data: FlowrSearchInput<Pipeline>, args: {
     criterion: SlicingCriteria;
 }): FlowrSearchElements<ParentInformation>;

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

@@ -6,6 +6,7 @@ const flowr_search_1 = require("../flowr-search");
 const parse_1 = require("../../slicing/criterion/parse");
 const assert_1 = require("../../util/assert");
 const query_1 = require("../../queries/query");
+const search_enrichers_1 = require("./search-enrichers");
 /**
  * All supported generators!
  */
@@ -55,22 +56,26 @@ function generateFrom(data, args) {
     return new flowr_search_1.FlowrSearchElements(Array.isArray(args.from) ? args.from : [args.from]);
 }
 function generateFromQuery(data, args) {
-    const nodes = new Set();
     const result = (0, query_1.executeQueries)({ ast: data.normalize, dataflow: data.dataflow, config: data.config }, args.from);
+    // collect involved nodes
+    const nodesByQuery = new Map();
     for (const [query, content] of Object.entries(result)) {
         if (query === '.meta') {
             continue;
         }
+        const nodes = new Set();
         const queryDef = query_1.SupportedQueries[query];
         for (const node of queryDef.flattenInvolvedNodes(content)) {
-            nodes.add({
-                node: data.normalize.idMap.get(node),
-                query: query,
-                queryResult: content
-            });
+            nodes.add({ node: data.normalize.idMap.get(node) });
         }
+        nodesByQuery.set(query, nodes);
     }
-    return new flowr_search_1.FlowrSearchElements([...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 [query, _] = [...nodesByQuery].find(([_, nodes]) => nodes.has(e));
+        return (0, search_enrichers_1.enrichElement)(e, elements, data, 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)) })));

package/search/search-executor/search-mappers.js

@@ -10,8 +10,9 @@ var Mapper;
 const Mappers = {
     [Mapper.Enrichment]: {
         mapper: (e, _data, enrichment) => {
-            const data = (0, search_enrichers_1.enrichmentContent)(e, enrichment);
-            return data !== undefined ? search_enrichers_1.Enrichments[enrichment].mapper(data) : [];
+            const enrichmentData = search_enrichers_1.Enrichments[enrichment];
+            const content = (0, search_enrichers_1.enrichmentContent)(e, enrichment);
+            return content !== undefined ? enrichmentData.mapper?.(content) ?? [] : [];
         }
     }
 };

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

@@ -4,7 +4,7 @@ import type { LastOfArray, Tail2TypesOrUndefined, TailOfArray } from '../../util
 import type { FlowrFilterExpression } from '../flowr-search-filters';
 import type { FlowrSearchGeneratorNode } from './search-generators';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { EnrichedFlowrSearchElement, Enrichment, EnrichmentArguments } from './search-enrichers';
+import type { Enrichment, EnrichmentElementArguments } from './search-enrichers';
 import type { Mapper, MapperArguments } from './search-mappers';
 /**
  * This is a union of all possible transformer node types
@@ -57,8 +57,8 @@ declare function getFilter<Elements extends FlowrSearchElement<ParentInformation
 }): CascadeEmpty<Elements, Elements | []>;
 declare function getWith<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { info, args }: {
     info: Enrichment;
-    args?: EnrichmentArguments<Enrichment>;
-}): FlowrSearchElements<ParentInformation, EnrichedFlowrSearchElement<ParentInformation>[]>;
+    args?: EnrichmentElementArguments<Enrichment>;
+}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
 declare function getMap<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { mapper, args }: {
     mapper: Mapper;
     args: MapperArguments<Mapper>;

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

@@ -96,7 +96,7 @@ function getFilter(data, elements, { filter }) {
     return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, normalize: data.normalize, dataflow: data.dataflow })));
 }
 function getWith(data, elements, { info, args }) {
-    return elements.mutate(elements => elements.map(e => (0, search_enrichers_1.enrich)(e, data, info, args)));
+    return elements.enrich(data, info, args).mutate(s => s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, data, info, args)));
 }
 function getMap(data, elements, { mapper, args }) {
     return elements.mutate(elements => elements.flatMap(e => (0, search_mappers_1.map)(e, data, mapper, args)));
@@ -105,7 +105,7 @@ function getMerge(
 /* search has to be unknown because it is a recursive type */
 data, elements, other) {
     const resultOther = (0, flowr_search_executor_1.runSearch)(other, data);
-    return elements.addAll(resultOther);
+    return elements.addAll([...resultOther.getElements()]);
 }
 function getUnique(data, elements) {
     return elements.mutate(e => e.reduce((acc, cur) => {

package/slicing/static/static-slicer.d.ts

@@ -6,17 +6,19 @@ import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing
 import type { SlicingCriteria } from '../criterion/parse';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
- * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
+ * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criteria to slice on.
+ * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+export declare function staticSlice(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
 export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation, envFingerprint: string): void;

package/slicing/static/static-slicer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.slicerLogger = void 0;
-exports.staticSlicing = staticSlicing;
+exports.staticSlice = staticSlice;
 exports.updatePotentialAddition = updatePotentialAddition;
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
@@ -12,22 +12,28 @@ const parse_1 = require("../criterion/parse");
 const environment_1 = require("../../dataflow/environments/environment");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const edge_1 = require("../../dataflow/graph/edge");
+const _00_slice_1 = require("../../core/steps/all/static-slicing/00-slice");
+const invert_dfg_1 = require("../../dataflow/graph/invert-dfg");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
- * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
+ * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criteria to slice on.
+ * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-function staticSlicing(graph, { idMap }, criteria, threshold = 75, cache) {
+function staticSlice(graph, { idMap }, criteria, direction, threshold = 75, cache) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
     const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
-    (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+    (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating ${direction} slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+    if (direction === _00_slice_1.SliceDirection.Forward) {
+        graph = (0, invert_dfg_1.invertDfg)(graph);
+    }
     const queue = new visiting_queue_1.VisitingQueue(threshold, cache);
     let minNesting = Number.MAX_SAFE_INTEGER;
     const sliceSeedIds = new Set();

package/util/collections/arrays.d.ts

@@ -88,3 +88,5 @@ export declare function equidistantSampling<T>(list: readonly T[], sampleCount:
  *
  */
 export declare function cartesianProduct<T>(...arrays: T[][]): T[][];
+/** merge two arrays, removing duplicates */
+export declare function uniqueArrayMerge<T>(left: readonly T[], right: readonly T[]): T[];

package/util/collections/arrays.js

@@ -10,6 +10,7 @@ exports.array2bag = array2bag;
 exports.arrayEqual = arrayEqual;
 exports.equidistantSampling = equidistantSampling;
 exports.cartesianProduct = cartesianProduct;
+exports.uniqueArrayMerge = uniqueArrayMerge;
 const assert_1 = require("../assert");
 /**
  * Splits the array every time the given predicate fires.
@@ -215,4 +216,12 @@ function equidistantSampling(list, sampleCount, rounding = 'ceil') {
 function cartesianProduct(...arrays) {
     return arrays.reduce((a, b) => a.flatMap(x => b.map(y => x.concat(y))), [[]]);
 }
+/** merge two arrays, removing duplicates */
+function uniqueArrayMerge(left, right) {
+    const result = new Set(left);
+    for (const elem of right) {
+        result.add(elem);
+    }
+    return Array.from(result);
+}
 //# sourceMappingURL=arrays.js.map

package/util/files.d.ts

@@ -40,17 +40,23 @@ export declare function writeTableAsCsv(table: Table, file: string, sep?: string
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLineSync} for a synchronous version.
  */
-export declare function readLineByLine(filePath: string, onLine: (line: Buffer, lineNumber: number) => Promise<void>): Promise<void>;
+export declare function readLineByLine(filePath: string, onLine: (line: Buffer, lineNumber: number) => Promise<void>, maxLines?: number): Promise<boolean>;
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether the file exists and all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLine} for an asynchronous version.
  */
-export declare function readLineByLineSync(filePath: string, onLine: (line: Buffer, lineNumber: number) => void): void;
+export declare function readLineByLineSync(filePath: string, onLine: (line: Buffer, lineNumber: number) => void, maxLines?: number): boolean;
 /**
  * Chops off the last part of the given directory path after a path separator, essentially returning the path's parent directory.
  * If an absolute path is passed, the returned path is also absolute.