@eagleoutice/flowr 2.2.15 → 2.2.16

package/r-bridge/lang-4.x/convert-values.js

@@ -7,6 +7,7 @@ exports.boolean2ts = boolean2ts;
 exports.number2ts = number2ts;
 exports.string2ts = string2ts;
 exports.isNA = isNA;
+const strings_1 = require("../../util/text/strings");
 class ValueConversionError extends Error {
     constructor(message) {
         super(message);
@@ -136,7 +137,7 @@ function string2ts(value) {
         const flags = value[1];
         if (flags === '"' || flags === '\'') {
             return {
-                str: value.slice(2, -1),
+                str: (0, strings_1.dropRawStringSurround)(value.slice(2, -1)),
                 quotes: flags,
                 flag: 'raw'
             };

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

@@ -1,6 +1,7 @@
 import Parser from 'web-tree-sitter';
 import type { RParseRequest } from '../../retriever';
 import type { SyncParser } from '../../parser';
+import type { TreeSitterEngineConfig } from '../../../config';
 export declare const DEFAULT_TREE_SITTER_R_WASM_PATH = "./node_modules/@eagleoutice/tree-sitter-r/tree-sitter-r.wasm";
 export declare const DEFAULT_TREE_SITTER_WASM_PATH = "./node_modules/web-tree-sitter/tree-sitter.wasm";
 /**
@@ -12,10 +13,11 @@ export declare class TreeSitterExecutor implements SyncParser<Parser.Tree> {
     private static language;
     /**
      * Initializes the underlying tree-sitter parser. This only needs to be called once globally.
+     * @param config - The configuration for the tree-sitter engine, which can include paths to the wasm files.
      * @param overrideWasmPath - The path to the tree-sitter-r wasm file, which takes precedence over the config and default paths if set.
      * @param overrideTreeSitterWasmPath - The path to the tree-sitter wasm file, which takes precedence over the config and default paths if set.
      */
-    static initTreeSitter(overrideWasmPath?: string, overrideTreeSitterWasmPath?: string): Promise<void>;
+    static initTreeSitter(config?: TreeSitterEngineConfig, overrideWasmPath?: string, overrideTreeSitterWasmPath?: string): Promise<void>;
     constructor();
     rVersion(): Promise<string | 'unknown' | 'none'>;
     treeSitterVersion(): number;

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

@@ -6,7 +6,6 @@ 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 config_1 = require("../../../config");
 const log_1 = require("../../../util/log");
 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';
@@ -20,11 +19,12 @@ class TreeSitterExecutor {
     static language;
     /**
      * Initializes the underlying tree-sitter parser. This only needs to be called once globally.
+     * @param config - The configuration for the tree-sitter engine, which can include paths to the wasm files.
      * @param overrideWasmPath - The path to the tree-sitter-r wasm file, which takes precedence over the config and default paths if set.
      * @param overrideTreeSitterWasmPath - The path to the tree-sitter wasm file, which takes precedence over the config and default paths if set.
      */
-    static async initTreeSitter(overrideWasmPath, overrideTreeSitterWasmPath) {
-        const treeSitterWasmPath = overrideTreeSitterWasmPath ?? (0, config_1.getEngineConfig)('tree-sitter')?.treeSitterWasmPath ?? exports.DEFAULT_TREE_SITTER_WASM_PATH;
+    static async initTreeSitter(config, overrideWasmPath, overrideTreeSitterWasmPath) {
+        const treeSitterWasmPath = overrideTreeSitterWasmPath ?? config?.treeSitterWasmPath ?? exports.DEFAULT_TREE_SITTER_WASM_PATH;
         // noinspection JSUnusedGlobalSymbols - this is used by emscripten, see https://emscripten.org/docs/api_reference/module.html
         await web_tree_sitter_1.default.init({
             locateFile: treeSitterWasmPath ? (path, prefix) => {
@@ -38,7 +38,7 @@ class TreeSitterExecutor {
             print: (s) => wasmLog.debug(s),
             printErr: (s) => wasmLog.error(s)
         });
-        const wasmPath = overrideWasmPath ?? (0, config_1.getEngineConfig)('tree-sitter')?.wasmPath ?? exports.DEFAULT_TREE_SITTER_R_WASM_PATH;
+        const wasmPath = overrideWasmPath ?? config?.wasmPath ?? exports.DEFAULT_TREE_SITTER_R_WASM_PATH;
         TreeSitterExecutor.language = await web_tree_sitter_1.default.Language.load(wasmPath);
     }
     constructor() {

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.d.ts

@@ -3,6 +3,6 @@ import type { Tree } from 'web-tree-sitter';
 /**
  * @param tree - The tree to normalize
  */
-export declare function normalizeTreeSitterTreeToAst(tree: Tree): RExpressionList;
+export declare function normalizeTreeSitterTreeToAst(tree: Tree, lax?: boolean): RExpressionList;
 export declare function makeTreeSitterLax(): void;
 export declare function makeTreeSitterStrict(): void;

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

@@ -12,13 +12,11 @@ const normalize_meta_1 = require("../ast/parser/main/normalize-meta");
 const arrays_1 = require("../../../util/collections/arrays");
 const r_function_call_1 = require("../ast/model/nodes/r-function-call");
 const strings_1 = require("../../../util/text/strings");
-const config_1 = require("../../../config");
 const log_1 = require("../../../util/log");
 /**
  * @param tree - The tree to normalize
  */
-function normalizeTreeSitterTreeToAst(tree) {
-    const lax = (0, config_1.getEngineConfig)('tree-sitter')?.lax;
+function normalizeTreeSitterTreeToAst(tree, lax) {
     if (lax) {
         makeTreeSitterLax();
     }
@@ -343,14 +341,18 @@ function convertTreeNode(node) {
         }
         case tree_sitter_types_1.TreeSitterType.FunctionDefinition: {
             const [name, paramsParens, body] = nonErrorChildren(node);
-            const params = (0, arrays_1.splitArrayOn)(paramsParens.children.slice(1, -1), x => x.type === 'comma');
+            const [comments, noCommentRawParams] = splitComments(paramsParens.children.slice(1, -1));
+            const params = (0, arrays_1.splitArrayOn)(noCommentRawParams, x => x.type === 'comma');
             return {
                 type: type_1.RType.FunctionDefinition,
                 parameters: params.map(n => convertTreeNode(n[0])),
                 body: (0, normalize_meta_1.ensureExpressionList)(convertTreeNode(body)),
                 location: makeSourceRange(name),
                 lexeme: name.text,
-                ...defaultInfo
+                info: {
+                    ...defaultInfo.info,
+                    additionalTokens: comments.map(c => c[1]),
+                }
             };
         }
         case tree_sitter_types_1.TreeSitterType.String:

package/r-bridge/shell.d.ts

@@ -1,6 +1,7 @@
 import { type MergeableRecord } from '../util/objects';
 import type { SemVer } from 'semver';
 import type { AsyncOrSync } from 'ts-essentials';
+import type { RShellEngineConfig } from '../config';
 import type { AsyncParser } from './parser';
 import type { RParseRequest } from './retriever';
 export type OutputStreamSelector = 'stdout' | 'stderr' | 'both';
@@ -68,7 +69,7 @@ export interface RShellOptions extends RShellSessionOptions {
     readonly sessionName: string;
 }
 export declare const DEFAULT_R_PATH: string;
-export declare function getDefaultRShellOptions(): RShellOptions;
+export declare function getDefaultRShellOptions(config?: RShellEngineConfig): RShellOptions;
 /**
  * The `RShell` represents an interactive session with the R interpreter.
  * You can configure it by {@link RShellOptions}.
@@ -85,7 +86,7 @@ export declare class RShell implements AsyncParser<string> {
     private readonly log;
     private versionCache;
     private tempDirs;
-    constructor(options?: Partial<RShellOptions>);
+    constructor(config?: RShellEngineConfig, options?: Partial<RShellOptions>);
     parse(request: RParseRequest): Promise<string>;
     private revive;
     /**

package/r-bridge/shell.js

@@ -46,7 +46,6 @@ const preload_1 = __importDefault(require("semver/preload"));
 const os_1 = require("../util/os");
 const fs_1 = __importDefault(require("fs"));
 const init_1 = require("./init");
-const config_1 = require("../config");
 const convert_values_1 = require("./lang-4.x/convert-values");
 const retriever_1 = require("./retriever");
 exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
@@ -62,10 +61,10 @@ exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
 };
 exports.DEFAULT_R_PATH = (0, os_1.getPlatform)() === 'windows' ? 'R.exe' : 'R';
 let DEFAULT_R_SHELL_OPTIONS = undefined;
-function getDefaultRShellOptions() {
+function getDefaultRShellOptions(config) {
     if (!DEFAULT_R_SHELL_OPTIONS) {
         DEFAULT_R_SHELL_OPTIONS = {
-            pathToRExecutable: (0, config_1.getEngineConfig)('r-shell')?.rPath ?? exports.DEFAULT_R_PATH,
+            pathToRExecutable: config?.rPath ?? exports.DEFAULT_R_PATH,
             // -s is a short form of --no-echo (and the old version --slave), but this one works in R 3 and 4
             // (see https://github.com/wch/r-source/commit/f1ff49e74593341c74c20de9517f31a22c8bcb04)
             commandLineOptions: ['--vanilla', '--quiet', '--no-save', '-s'],
@@ -97,8 +96,8 @@ class RShell {
     versionCache = null;
     // should never be more than one, but let's be sure
     tempDirs = new Set();
-    constructor(options) {
-        this.options = { ...getDefaultRShellOptions(), ...options };
+    constructor(config, options) {
+        this.options = { ...getDefaultRShellOptions(config), ...options };
         this.log = log_1.log.getSubLogger({ name: this.options.sessionName });
         this.session = new RShellSession(this.options, this.log);
         this.revive();

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

@@ -1,6 +1,6 @@
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { FlowrSearchElement, FlowrSearchElementFromQuery, FlowrSearchElements, FlowrSearchGetFilter } from './flowr-search';
-import type { FlowrFilterExpression } from './flowr-search-filters';
+import type { FlowrFilter, FlowrFilterExpression } from './flowr-search-filters';
 import type { FlowrSearchGeneratorNode, GeneratorNames } from './search-executor/search-generators';
 import type { FlowrSearchTransformerNode, GetOutputOfTransformer, TransformerNames } from './search-executor/search-transformer';
 import type { SlicingCriteria } from '../slicing/criterion/parse';
@@ -155,7 +155,7 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
     /**
      * only returns the elements that match the given filter.
      */
-    filter(filter: FlowrFilterExpression): FlowrSearchBuilderOut<Generator, Transformers, Info, 'filter'>;
+    filter<Filter extends FlowrFilter>(filter: FlowrFilterExpression<Filter>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'filter'>;
     /**
      * first either returns the first element of the search or nothing, if no elements are present.
      */
@@ -201,6 +201,10 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
      * merge combines the search results with those of another search.
      */
     merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info>;
+    /**
+     * Removes duplicate elements based on the ids of the elements.
+     */
+    unique(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'unique'>;
     /**
      * Construct the final search (this may happen automatically with most search handlers).
      *

package/search/flowr-search-builder.js

@@ -195,6 +195,13 @@ class FlowrSearchBuilder {
         this.search.push({ type: 'transformer', name: 'merge', args: { generator: other.generator, search: other.search } });
         return this;
     }
+    /**
+     * Removes duplicate elements based on the ids of the elements.
+     */
+    unique() {
+        this.search.push({ type: 'transformer', name: 'unique', args: undefined });
+        return this;
+    }
     /**
      * Construct the final search (this may happen automatically with most search handlers).
      *

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

@@ -2,23 +2,47 @@ import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import type { VertexType } from '../dataflow/graph/vertex';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
-import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { FlowrSearchElement } from './flowr-search';
+import type { MergeableRecord } from '../util/objects';
+import type { Enrichment } from './search-executor/search-enrichers';
 export type FlowrFilterName = keyof typeof FlowrFilters;
+interface FlowrFilterWithArgs<Filter extends FlowrFilterName, Args extends FlowrFilterArgs<Filter>> {
+    name: Filter;
+    args: Args;
+}
 export declare enum FlowrFilter {
-    DropEmptyArguments = "drop-empty-arguments"
+    /**
+     * Drops search elements that represent empty arguments. Specifically, all nodes that are arguments and have an undefined name are skipped.
+     * This filter does not accept any arguments.
+     */
+    DropEmptyArguments = "drop-empty-arguments",
+    /**
+     * Only returns search elements whose enrichments' JSON representations match a given test regular expression.
+     * This filter accepts {@link MatchesEnrichmentArgs}, which includes the enrichment to match for, as well as the regular expression to test the enrichment's (non-pretty-printed) JSON representation for.
+     * To test for included function names in an enrichment like {@link Enrichment.CallTargets}, the helper function {@link testFunctionsIgnoringPackage} can be used.
+     */
+    MatchesEnrichment = "matches-enrichment"
 }
+export type FlowrFilterFunction<T extends MergeableRecord> = (e: FlowrSearchElement<ParentInformation>, args: T) => boolean;
 export declare const ValidFlowrFilters: Set<string>;
 export declare const ValidFlowrFiltersReverse: {
     [k: string]: string;
 };
 export declare const FlowrFilters: {
-    readonly "drop-empty-arguments": (n: RNode<ParentInformation>) => boolean;
+    readonly "drop-empty-arguments": (e: FlowrSearchElement<ParentInformation>, _args: never) => boolean;
+    readonly "matches-enrichment": (e: FlowrSearchElement<ParentInformation>, args: MatchesEnrichmentArgs<Enrichment>) => boolean;
 };
-type ValidFilterTypes = FlowrFilterName | RType | VertexType;
+export type FlowrFilterArgs<F extends FlowrFilter> = typeof FlowrFilters[F] extends FlowrFilterFunction<infer Args> ? Args : never;
+export interface MatchesEnrichmentArgs<E extends Enrichment> extends MergeableRecord {
+    enrichment: E;
+    test: RegExp;
+}
+export declare function testFunctionsIgnoringPackage(functions: 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}.
  */
-export type FlowrFilterExpression = FlowrFilterCombinator | ValidFilterTypes;
+export type FlowrFilterExpression<F extends FlowrFilter = FlowrFilter> = FlowrFilterCombinator | ValidFilterTypes<F>;
 interface BooleanBinaryNode<Composite> {
     readonly type: 'and' | 'or' | 'xor';
     readonly left: Composite;
@@ -38,7 +62,7 @@ type LeafVertexType = {
 };
 type LeafSpecial = {
     readonly type: 'special';
-    readonly value: string;
+    readonly value: FlowrFilterName | FlowrFilterWithArgs<FlowrFilter, FlowrFilterArgs<FlowrFilter>>;
 };
 type Leaf = LeafRType | LeafVertexType | LeafSpecial;
 type BooleanNode = BooleanBinaryNode<BooleanNode> | BooleanUnaryNode<BooleanNode> | Leaf;
@@ -66,9 +90,9 @@ export declare function isBinaryTree(tree: unknown): tree is {
     tree: BooleanNode;
 };
 interface FilterData {
-    readonly node: RNode<ParentInformation>;
+    readonly element: FlowrSearchElement<ParentInformation>;
     readonly normalize: NormalizedAst;
     readonly dataflow: DataflowInformation;
 }
-export declare function evalFilter(filter: FlowrFilterExpression, data: FilterData): boolean;
+export declare function evalFilter<Filter extends FlowrFilter>(filter: FlowrFilterExpression<Filter>, data: FilterData): boolean;
 export {};

package/search/flowr-search-filters.js

@@ -1,22 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrFilterCombinator = exports.FlowrFilters = exports.ValidFlowrFiltersReverse = exports.ValidFlowrFilters = exports.FlowrFilter = void 0;
+exports.testFunctionsIgnoringPackage = testFunctionsIgnoringPackage;
 exports.binaryTreeToString = binaryTreeToString;
 exports.isBinaryTree = isBinaryTree;
 exports.evalFilter = evalFilter;
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const vertex_1 = require("../dataflow/graph/vertex");
+const search_enrichers_1 = require("./search-executor/search-enrichers");
 var FlowrFilter;
 (function (FlowrFilter) {
+    /**
+     * Drops search elements that represent empty arguments. Specifically, all nodes that are arguments and have an undefined name are skipped.
+     * This filter does not accept any arguments.
+     */
     FlowrFilter["DropEmptyArguments"] = "drop-empty-arguments";
+    /**
+     * Only returns search elements whose enrichments' JSON representations match a given test regular expression.
+     * This filter accepts {@link MatchesEnrichmentArgs}, which includes the enrichment to match for, as well as the regular expression to test the enrichment's (non-pretty-printed) JSON representation for.
+     * To test for included function names in an enrichment like {@link Enrichment.CallTargets}, the helper function {@link testFunctionsIgnoringPackage} can be used.
+     */
+    FlowrFilter["MatchesEnrichment"] = "matches-enrichment";
 })(FlowrFilter || (exports.FlowrFilter = FlowrFilter = {}));
 exports.ValidFlowrFilters = new Set(Object.values(FlowrFilter));
 exports.ValidFlowrFiltersReverse = Object.fromEntries(Object.entries(FlowrFilter).map(([k, v]) => [v, k]));
 exports.FlowrFilters = {
-    [FlowrFilter.DropEmptyArguments]: (n) => {
-        return n.type !== type_1.RType.Argument || n.name !== undefined;
-    }
+    [FlowrFilter.DropEmptyArguments]: ((e, _args) => {
+        return e.node.type !== type_1.RType.Argument || e.node.name !== undefined;
+    }),
+    [FlowrFilter.MatchesEnrichment]: ((e, args) => {
+        const content = JSON.stringify((0, search_enrichers_1.enrichmentContent)(e, args.enrichment));
+        return content !== undefined && args.test.test(content);
+    })
 };
+function testFunctionsIgnoringPackage(functions) {
+    return new RegExp(`"(.+:::?)?(${functions.join('|')})"`);
+}
 /**
  * @see {@link FlowrFilterCombinator.is}
  * @see {@link evalFilter}
@@ -28,8 +47,17 @@ class FlowrFilterCombinator {
         this.tree = this.unpack(init);
     }
     static is(value) {
-        if (typeof value === 'object') {
-            return new this(value);
+        if (typeof value === 'string' && exports.ValidFlowrFilters.has(value)) {
+            return new this({ type: 'special', value: value });
+        }
+        else if (typeof value === 'object') {
+            const name = value?.name;
+            if (name && exports.ValidFlowrFilters.has(name)) {
+                return new this({ type: 'special', value: value });
+            }
+            else {
+                return new this(value);
+            }
         }
         else if (type_1.ValidRTypes.has(value)) {
             return new this({ type: 'r-type', value: value });
@@ -37,9 +65,6 @@ class FlowrFilterCombinator {
         else if (vertex_1.ValidVertexTypes.has(value)) {
             return new this({ type: 'vertex-type', value: value });
         }
-        else if (exports.ValidFlowrFilters.has(value)) {
-            return new this({ type: 'special', value: value });
-        }
         else {
             throw new Error(`Invalid filter value: ${value}`);
         }
@@ -97,7 +122,7 @@ const typeToSymbol = {
 };
 function treeToStringImpl(tree, depth) {
     if (tree.type === 'r-type' || tree.type === 'vertex-type' || tree.type === 'special') {
-        return tree.value;
+        return typeof tree.value === 'string' ? tree.value : `${tree.value.name}@${JSON.stringify(tree.value.args)}`;
     }
     if (tree.type === 'not') {
         return `${typeToSymbol[tree.type]}${treeToStringImpl(tree.operand, depth)}`;
@@ -114,14 +139,16 @@ const evalVisit = {
     or: ({ left, right }, data) => evalTree(left, data) || evalTree(right, data),
     xor: ({ left, right }, data) => evalTree(left, data) !== evalTree(right, data),
     not: ({ operand }, data) => !evalTree(operand, data),
-    'r-type': ({ value }, { node }) => node.type === value,
-    'vertex-type': ({ value }, { dataflow: { graph }, node }) => graph.getVertex(node.info.id)?.tag === value,
-    'special': ({ value }, { node }) => {
-        const getHandler = exports.FlowrFilters[value];
+    'r-type': ({ value }, { element }) => element.node.type === value,
+    'vertex-type': ({ value }, { dataflow: { graph }, element }) => graph.getVertex(element.node.info.id)?.tag === value,
+    'special': ({ value }, { element }) => {
+        const name = typeof value === 'string' ? value : value.name;
+        const args = typeof value === 'string' ? undefined : value.args;
+        const getHandler = exports.FlowrFilters[name];
         if (getHandler) {
-            return getHandler(node);
+            return getHandler(element, args);
         }
-        throw new Error(`Special filter not implemented: ${value}`);
+        throw new Error(`Couldn't find special filter with name ${name}`);
     }
 };
 function evalTree(tree, data) {

package/search/flowr-search.d.ts

@@ -5,6 +5,8 @@ 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';
 /**
  * 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.
@@ -16,6 +18,7 @@ export interface FlowrSearchElementFromQuery<Info> extends FlowrSearchElement<In
     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;
@@ -49,6 +52,7 @@ export interface FlowrSearchGetFilter extends Record<string, unknown> {
 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>;

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

@@ -17,7 +17,7 @@ export interface EnrichmentData<EnrichmentContent extends MergeableRecord, Enric
     /**
      * 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) => EnrichmentContent;
+    readonly enrich: (e: FlowrSearchElement<ParentInformation>, data: FlowrSearchInput<Pipeline>, args: EnrichmentArguments | undefined, previousValue: EnrichmentContent | undefined) => EnrichmentContent;
     /**
      * The mapping function used by the {@link Mapper.Enrichment} mapper.
      */
@@ -52,14 +52,18 @@ export declare const Enrichments: {
         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>>> & {
             normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
             dataflow: import("../../dataflow/info").DataflowInformation;
-        }) => CallTargetsContent;
+            config: import("../../config").FlowrConfigOptions;
+        }, args: {
+            onlyBuiltin?: boolean;
+        } | undefined, prev: CallTargetsContent | undefined) => CallTargetsContent;
         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>>> & {
             normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
             dataflow: import("../../dataflow/info").DataflowInformation;
-        }, args: Omit<LinkToLastCall<string | RegExp>, "type">[] | undefined) => LastCallContent;
+            config: import("../../config").FlowrConfigOptions;
+        }, args: Omit<LinkToLastCall<string | RegExp>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
 };

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

@@ -24,7 +24,7 @@ var Enrichment;
  */
 exports.Enrichments = {
     [Enrichment.CallTargets]: {
-        enrich: (e, data) => {
+        enrich: (e, data, args, prev) => {
             // we don't resolve aliases here yet!
             const content = { targets: [] };
             const callVertex = data.dataflow.graph.getVertex(e.node.info.id);
@@ -32,34 +32,42 @@ exports.Enrichments = {
                 const origins = (0, dfg_get_origin_1.getOriginInDfg)(data.dataflow.graph, callVertex.id);
                 if (!origins || origins.length === 0) {
                     content.targets = [(0, node_id_1.recoverName)(callVertex.id, data.normalize.idMap)];
-                    return content;
                 }
-                // find call targets in user code (which have ids!)
-                content.targets = content.targets.concat(origins.map(o => {
-                    switch (o.type) {
-                        case 2 /* OriginType.FunctionCallOrigin */:
-                            return {
-                                node: data.normalize.idMap.get(o.id),
-                            };
-                        case 3 /* OriginType.BuiltInFunctionOrigin */:
-                            return o.fn.name;
-                        default:
-                            return undefined;
+                else {
+                    // find call targets in user code (which have ids!)
+                    content.targets = content.targets.concat(origins.map(o => {
+                        switch (o.type) {
+                            case 2 /* OriginType.FunctionCallOrigin */:
+                                return {
+                                    node: data.normalize.idMap.get(o.id),
+                                };
+                            case 3 /* OriginType.BuiltInFunctionOrigin */:
+                                return o.fn.name;
+                            default:
+                                return undefined;
+                        }
+                    }).filter(assert_1.isNotUndefined));
+                    if (content.targets.length === 0) {
+                        content.targets = [(0, node_id_1.recoverName)(callVertex.id, data.normalize.idMap)];
                     }
-                }).filter(assert_1.isNotUndefined));
-                if (content.targets.length === 0) {
-                    content.targets = [(0, node_id_1.recoverName)(callVertex.id, data.normalize.idMap)];
                 }
             }
+            // if there is a call target that is not built-in (ie a custom function), we don't want to include it here
+            if (args?.onlyBuiltin && content.targets.some(t => typeof t !== 'string')) {
+                content.targets = [];
+            }
+            if (prev) {
+                content.targets.push(...prev.targets);
+            }
             return content;
         },
         // as built-in call target enrichments are not nodes, we don't return them as part of the mapper!
         mapper: ({ targets }) => targets.map(t => t).filter(t => t.node !== undefined)
     },
     [Enrichment.LastCall]: {
-        enrich: (e, data, args) => {
+        enrich: (e, data, args, prev) => {
             (0, assert_1.guard)(args && args.length, `${Enrichment.LastCall} enrichment requires at least one argument`);
-            const content = { linkedIds: [] };
+            const content = prev ?? { linkedIds: [] };
             const vertex = data.dataflow.graph.get(e.node.info.id);
             if (vertex !== undefined && vertex[0].tag === vertex_1.VertexType.FunctionCall) {
                 const cfg = (0, extract_cfg_1.extractSimpleCfg)(data.normalize);
@@ -90,11 +98,12 @@ function enrichmentContent(e, enrichment) {
 }
 function enrich(e, data, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
+    const prev = e?.enrichments;
     return {
         ...e,
         enrichments: {
-            ...e?.enrichments ?? {},
-            [enrichment]: enrichmentData.enrich(e, data, args)
+            ...prev ?? {},
+            [enrichment]: enrichmentData.enrich(e, data, args, prev?.[enrichment])
         }
     };
 }

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

@@ -56,7 +56,7 @@ function generateFrom(data, args) {
 }
 function generateFromQuery(data, args) {
     const nodes = new Set();
-    const result = (0, query_1.executeQueries)({ ast: data.normalize, dataflow: data.dataflow }, args.from);
+    const result = (0, query_1.executeQueries)({ ast: data.normalize, dataflow: data.dataflow, config: data.config }, args.from);
     for (const [query, content] of Object.entries(result)) {
         if (query === '.meta') {
             continue;

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

@@ -29,6 +29,7 @@ export declare const transformers: {
     readonly skip: typeof getSkip;
     readonly filter: typeof getFilter;
     readonly merge: typeof getMerge;
+    readonly unique: typeof getUnique;
     readonly select: typeof getSelect;
     readonly with: typeof getWith;
     readonly map: typeof getMap;
@@ -66,4 +67,5 @@ declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>
     search: unknown[];
     generator: FlowrSearchGeneratorNode;
 }): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
+declare function getUnique<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, Elements>;
 export {};

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

@@ -19,6 +19,7 @@ exports.transformers = {
     skip: getSkip,
     filter: getFilter,
     merge: getMerge,
+    unique: getUnique,
     select: getSelect,
     with: getWith,
     map: getMap
@@ -92,7 +93,7 @@ function getSkip(data, elements, { count }) {
     return elements.mutate(e => sortFully(e).slice(count));
 }
 function getFilter(data, elements, { filter }) {
-    return elements.mutate(e => e.filter(({ node }) => (0, flowr_search_filters_1.evalFilter)(filter, { node, normalize: data.normalize, dataflow: data.dataflow })));
+    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)));
@@ -106,4 +107,12 @@ data, elements, other) {
     const resultOther = (0, flowr_search_executor_1.runSearch)(other, data);
     return elements.addAll(resultOther);
 }
+function getUnique(data, elements) {
+    return elements.mutate(e => e.reduce((acc, cur) => {
+        if (!acc.some(el => el.node.id === cur.node.id)) {
+            acc.push(cur);
+        }
+        return acc;
+    }, []));
+}
 //# sourceMappingURL=search-transformer.js.map

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

@@ -14,7 +14,7 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  *
  * @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 criterias to slice on.
+ * @param criteria  - The criteria to slice on.
  * @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.
  */

package/slicing/static/static-slicer.js

@@ -12,7 +12,6 @@ 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 config_1 = require("../../config");
 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).
@@ -21,11 +20,11 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  *
  * @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 criterias to slice on.
+ * @param criteria  - The criteria to slice on.
  * @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 = (0, config_1.getConfig)().solver.slicer?.threshold ?? 75, cache) {
+function staticSlicing(graph, { idMap }, criteria, 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(', ')}`);