@eagleoutice/flowr 2.6.1 → 2.6.3

package/reconstruct/reconstruct.d.ts

@@ -5,22 +5,28 @@
  */
 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 { AutoSelectPredicate } from './auto-select/auto-select-defaults';
-type Selection = ReadonlySet<NodeId>;
+import { type AutoSelectPredicate } from './auto-select/auto-select-defaults';
+interface Selection {
+    /**
+     * The set of node ids to be reconstructed.
+     */
+    nodes: ReadonlySet<NodeId>;
+    /**
+     * @see {@link ReconstructRequiredInput#reconstructFiles}
+     */
+    reconstructFiles?: 'all' | number[];
+}
 export declare const reconstructLogger: import("tslog").Logger<import("tslog").ILogObj>;
 export interface ReconstructionResult {
-    code: string;
+    /** Returns the reconstructed code as string or array of code reconstructions (corresponding to the desired file indices in the {@link Selection}) */
+    code: string | string[];
     /** number of lines that contain nodes that triggered the `autoSelectIf` predicate {@link reconstructToCode} */
     linesWithAutoSelected: number;
 }
-/**
- * Reconstructs parts of a normalized R ast into R code on an expression basis.
- *
- * @param ast          - The {@link NormalizedAst|normalized ast} to be used as a basis for reconstruction
- * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
- * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
- *
- * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
- */
+export declare function reconstructToCode(ast: NormalizedAst, selection: Selection & {
+    reconstructFiles?: [number] | undefined;
+}, autoSelectIf?: AutoSelectPredicate): ReconstructionResult & {
+    code: string;
+};
 export declare function reconstructToCode(ast: NormalizedAst, selection: Selection, autoSelectIf?: AutoSelectPredicate): ReconstructionResult;
 export {};

package/reconstruct/reconstruct.js

@@ -408,27 +408,25 @@ function getIndentString(indent) {
 function prettyPrintCodeToString(code, lf = '\n') {
     return code.map(({ line, indent }) => `${getIndentString(indent)}${line}`).join(lf);
 }
-function removeOuterExpressionListIfApplicable(result, linesWithAutoSelected) {
+function removeOuterExpressionListIfApplicable(result) {
     if (result.length > 1 && result[0].line === '{' && result[result.length - 1].line === '}') {
         // remove outer block
-        return { code: prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1)), linesWithAutoSelected };
+        return prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1));
     }
     else {
-        return { code: prettyPrintCodeToString(result), linesWithAutoSelected };
+        return prettyPrintCodeToString(result);
     }
 }
 /**
  * Reconstructs parts of a normalized R ast into R code on an expression basis.
- *
  * @param ast          - The {@link NormalizedAst|normalized ast} to be used as a basis for reconstruction
  * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
- * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
- *
+ * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node
  * @returns The number of lines for which `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
 function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1.doNotAutoSelect) {
     if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
-        exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
+        exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection.nodes])} for files: ${JSON.stringify(selection.reconstructFiles)}`);
     }
     // we use a wrapper to count the number of lines for which the autoSelectIf predicate triggered
     const linesWithAutoSelected = new Set();
@@ -441,9 +439,20 @@ function reconstructToCode(ast, selection, autoSelectIf = auto_select_defaults_1
         }
         return result;
     };
+    const indices = selection.reconstructFiles === 'all' ? ast.ast.files.map((_, i) => i) : (selection.reconstructFiles ?? [0]);
+    (0, assert_1.guard)(indices.every(i => i >= 0 && i < ast.ast.files.length), `reconstructToCode: reconstructFiles contains invalid file indices: ${JSON.stringify(indices)} for ast with ${ast.ast.files.length} files`);
+    const results = [];
     // fold of the normalized ast
-    const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper, fullAst: ast }, reconstructAstFolds);
-    (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(result)}`);
-    return removeOuterExpressionListIfApplicable(result, linesWithAutoSelected.size);
+    for (const i of indices) {
+        if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
+            exports.reconstructLogger.trace(`reconstructing file index ${i} with root id ${ast.ast.files[i].root.info.id}`);
+        }
+        results.push(removeOuterExpressionListIfApplicable((0, stateful_fold_1.foldAstStateful)(ast.ast.files[i].root, { selection: selection.nodes, autoSelectIf: autoSelectIfWrapper, fullAst: ast }, reconstructAstFolds)));
+    }
+    (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(results)}`);
+    return {
+        code: indices.length === 1 ? results[0] : results,
+        linesWithAutoSelected: linesWithAutoSelected.size
+    };
 }
 //# sourceMappingURL=reconstruct.js.map

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

@@ -6,9 +6,9 @@ import type { FlowrSearchTransformerNode, GetOutputOfTransformer, TransformerNam
 import type { SlicingCriteria } from '../slicing/criterion/parse';
 import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { Enrichment, EnrichmentElementArguments } from './search-executor/search-enrichers';
-import type { MapperArguments } from './search-executor/search-mappers';
-import { Mapper } from './search-executor/search-mappers';
+import { type MapperArguments, Mapper } from './search-executor/search-mappers';
 import type { Query } from '../queries/query';
+import type TreeSitter from 'web-tree-sitter';
 type FlowrCriteriaReturn<C extends SlicingCriteria> = FlowrSearchElements<ParentInformation, C extends [] ? never : C extends [infer _] ? [
     FlowrSearchElement<ParentInformation>
 ] : FlowrSearchElement<ParentInformation>[]>;
@@ -29,6 +29,11 @@ export declare const FlowrSearchGenerator: {
      * Please note that, due to the fact that not every query involves dataflow nodes, the search may not contain any elements at all for certain queries.
      */
     readonly fromQuery: (...from: readonly Query[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+    /**
+     * Initializes a new search query based on the results of the given tree-sitter syntax query.
+     * Please note that this search generator is incompatible with the {@link RShell} parser and only works when using flowR with the {@link TreeSitterExecutor}.
+     */
+    readonly syntax: (source: TreeSitter.Query | string, ...captures: readonly string[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
     /**
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
@@ -87,6 +92,11 @@ export declare const Q: {
      * Please note that, due to the fact that not every query involves dataflow nodes, the search may not contain any elements at all for certain queries.
      */
     readonly fromQuery: (...from: readonly Query[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+    /**
+     * Initializes a new search query based on the results of the given tree-sitter syntax query.
+     * Please note that this search generator is incompatible with the {@link RShell} parser and only works when using flowR with the {@link TreeSitterExecutor}.
+     */
+    readonly syntax: (source: TreeSitter.Query | string, ...captures: readonly string[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
     /**
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
@@ -130,7 +140,6 @@ export type FlowrSearchBuilderType<Generator extends GeneratorNames = GeneratorN
 /**
  * The search query is a combination of a generator and a list of transformers
  * and allows this view to pass such queries in a serialized form.
- *
  * @typeParam Transformers - The list of transformers that are applied to the generator's output.
  */
 export interface FlowrSearch<Info = ParentInformation, _Generator extends GeneratorNames = GeneratorNames, _Transformers extends readonly TransformerNames[] = readonly TransformerNames[], _ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> {
@@ -143,7 +152,6 @@ type FlowrSearchBuilderOut<Generator extends GeneratorNames, Transformers extend
  * Please use the {@link Q} object to create an object of this class!
  * In the end, you _can_ freeze the search by calling {@link FlowrSearchBuilder#build},
  * however, the search executors may do that for you.
- *
  * @see {@link FlowrSearchGenerator}
  * @see {@link FlowrSearch}
  * @see {@link FlowrSearchLike}
@@ -207,7 +215,6 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
     unique(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'unique'>;
     /**
      * Construct the final search (this may happen automatically with most search handlers).
-     *
      * @param shouldOptimize - This may optimize the search.
      */
     build(shouldOptimize?: boolean): FlowrSearch<Info, Generator, Transformers, ElementType>;

package/search/flowr-search-builder.js

@@ -26,6 +26,13 @@ exports.FlowrSearchGenerator = {
     fromQuery(...from) {
         return new FlowrSearchBuilder({ type: 'generator', name: 'from-query', args: { from } });
     },
+    /**
+     * Initializes a new search query based on the results of the given tree-sitter syntax query.
+     * Please note that this search generator is incompatible with the {@link RShell} parser and only works when using flowR with the {@link TreeSitterExecutor}.
+     */
+    syntax(source, ...captures) {
+        return new FlowrSearchBuilder({ type: 'generator', name: 'syntax', args: { source, captures } });
+    },
     /**
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
@@ -95,7 +102,6 @@ exports.Q = exports.FlowrSearchGenerator;
  * Please use the {@link Q} object to create an object of this class!
  * In the end, you _can_ freeze the search by calling {@link FlowrSearchBuilder#build},
  * however, the search executors may do that for you.
- *
  * @see {@link FlowrSearchGenerator}
  * @see {@link FlowrSearch}
  * @see {@link FlowrSearchLike}
@@ -204,7 +210,6 @@ class FlowrSearchBuilder {
     }
     /**
      * Construct the final search (this may happen automatically with most search handlers).
-     *
      * @param shouldOptimize - This may optimize the search.
      */
     build(shouldOptimize = true) {

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

@@ -1,7 +1,7 @@
-import type { FlowrSearch, FlowrSearchLike, SearchOutput } from './flowr-search-builder';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import { type FlowrSearch, type FlowrSearchLike, type SearchOutput } from './flowr-search-builder';
+import type { ReadonlyFlowrAnalysisProvider } 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>(search: S, input: FlowrAnalysisProvider): Promise<GetSearchElements<SearchOutput<S>>>;
+export declare function runSearch<S extends FlowrSearchLike>(search: S, input: ReadonlyFlowrAnalysisProvider): Promise<GetSearchElements<SearchOutput<S>>>;

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

@@ -2,7 +2,7 @@ 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 } from './flowr-search';
-import type { Enrichment } from './search-executor/search-enrichers';
+import { type Enrichment } from './search-executor/search-enrichers';
 import type { BuiltInMappingName } from '../dataflow/environments/built-in';
 import type { DataflowInformation } from '../dataflow/info';
 export type FlowrFilterName = keyof typeof FlowrFilters;
@@ -52,6 +52,9 @@ export interface OriginKindArgs {
     matchType?: 'some' | 'every';
     keepNonFunctionCalls?: boolean;
 }
+/**
+ * Helper to create a regular expression that matches function names, ignoring their package.
+ */
 export declare function testFunctionsIgnoringPackage(functions: readonly string[]): RegExp;
 type ValidFilterTypes<F extends FlowrFilter = FlowrFilter> = FlowrFilterName | FlowrFilterWithArgs<F, FlowrFilterArgs<F>> | RType | VertexType;
 /**
@@ -100,7 +103,14 @@ export declare class FlowrFilterCombinator {
     private unpack;
     get(): BooleanNode;
 }
+/**
+ * Converts the given binary tree to a string representation.
+ */
 export declare function binaryTreeToString(tree: BooleanNode): string;
+/**
+ * Checks whether the given value is a binary tree combinator.
+ * @see {@link FlowrFilterCombinator}
+ */
 export declare function isBinaryTree(tree: unknown): tree is {
     tree: BooleanNode;
 };
@@ -110,5 +120,8 @@ interface FilterData {
         dataflow: DataflowInformation;
     };
 }
+/**
+ * Evaluates the given filter expression against the provided data.
+ */
 export declare function evalFilter<Filter extends FlowrFilter>(filter: FlowrFilterExpression<Filter>, data: FilterData): boolean;
 export {};

package/search/flowr-search-filters.js

@@ -49,6 +49,9 @@ exports.FlowrFilters = {
         return args.matchType === 'every' ? origins.every(match) : origins.some(match);
     })
 };
+/**
+ * Helper to create a regular expression that matches function names, ignoring their package.
+ */
 function testFunctionsIgnoringPackage(functions) {
     return new RegExp(`"(.+:::?)?(${functions.join('|')})"`);
 }
@@ -120,6 +123,9 @@ class FlowrFilterCombinator {
     }
 }
 exports.FlowrFilterCombinator = FlowrFilterCombinator;
+/**
+ * Converts the given binary tree to a string representation.
+ */
 function binaryTreeToString(tree) {
     const res = treeToStringImpl(tree, 0);
     // drop outer parens
@@ -147,6 +153,10 @@ function treeToStringImpl(tree, depth) {
     const right = treeToStringImpl(tree.right, depth + 1);
     return `(${left} ${typeToSymbol[tree.type]} ${right})`;
 }
+/**
+ * Checks whether the given value is a binary tree combinator.
+ * @see {@link FlowrFilterCombinator}
+ */
 function isBinaryTree(tree) {
     return typeof tree === 'object' && tree !== null && 'tree' in tree;
 }
@@ -171,6 +181,9 @@ function evalTree(tree, data) {
     /* we ensure that the types fit */
     return evalVisit[tree.type](tree, data);
 }
+/**
+ * Evaluates the given filter expression against the provided data.
+ */
 function evalFilter(filter, data) {
     /* common lift, this can be improved easily :D */
     const tree = FlowrFilterCombinator.is(filter);

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

@@ -6,5 +6,11 @@ export interface FlowrSearchMermaidBuilderOptions {
  * Converts a {@link FlowrSearchLike} object to a mermaid flowchart.
  */
 export declare function flowrSearchToMermaid(search: FlowrSearchLike, conf?: FlowrSearchMermaidBuilderOptions): string;
+/**
+ * Converts a {@link FlowrSearchLike} object to an ASCII representation.
+ */
 export declare function flowrSearchToAscii(search: FlowrSearchLike): string;
+/**
+ * Converts a {@link FlowrSearchLike} object to code that can be used to recreate it.
+ */
 export declare function flowrSearchToCode(search: FlowrSearchLike): string;

package/search/flowr-search-printer.js

@@ -37,6 +37,9 @@ function argsToAsciiString(args) {
     return Object.entries(args).map(([key, value]) => `${key}: ${(0, flowr_search_filters_1.isBinaryTree)(value) ? '_' + (0, flowr_search_filters_1.binaryTreeToString)(value.tree) + '_' : JSON.stringify(value)}`)
         .join(', ');
 }
+/**
+ * Converts a {@link FlowrSearchLike} object to an ASCII representation.
+ */
 function flowrSearchToAscii(search) {
     return (0, flowr_search_traverse_1.traverseFlowrSearchBuilderType)(search, ({ name, args }) => `${name}(${argsToAsciiString(args)})`, (acc, { name, args }) => `${acc} --> ${name}(${argsToAsciiString(args)})`);
 }
@@ -47,6 +50,9 @@ function argsToCodeString(args) {
     return Object.entries(args).map(([, value]) => `${JSON.stringify(value)}`)
         .join(', ');
 }
+/**
+ * Converts a {@link FlowrSearchLike} object to code that can be used to recreate it.
+ */
 function flowrSearchToCode(search) {
     return (0, flowr_search_traverse_1.traverseFlowrSearchBuilderType)(search, (node) => `Q.${flowrGeneratorToCode(node)}`, (acc, node) => `${acc}.${flowrTransformerToCode(node)}`);
 }

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

@@ -1,4 +1,4 @@
-import type { FlowrSearchLike } from './flowr-search-builder';
+import { type FlowrSearchLike } from './flowr-search-builder';
 import type { FlowrSearchGeneratorNode } from './search-executor/search-generators';
 import type { FlowrSearchTransformerNode } from './search-executor/search-transformer';
 /**

package/search/flowr-search.d.ts

@@ -1,7 +1,7 @@
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { Enrichment, EnrichmentElementContent, EnrichmentSearchArguments, EnrichmentSearchContent } from './search-executor/search-enrichers';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import { type Enrichment, type EnrichmentElementContent, type EnrichmentSearchArguments, type EnrichmentSearchContent } from './search-executor/search-enrichers';
+import type { ReadonlyFlowrAnalysisProvider } 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.
@@ -41,6 +41,18 @@ export interface FlowrSearchGetFilter extends Record<string, unknown> {
      * The node must have the given id.
      */
     readonly id?: NodeId;
+    /**
+     * The node must stem form a file with the given path matching the regex
+     * Please note that you can address the full path!
+     * @example
+     * ```ts
+     * // matches all files in any 'tests' folder
+     * filePath: '.*\\tests\\.*'
+     * // matches all files named 'myfile.R' in any folder
+     * filePath: '.*\\/myfile\\.R$'
+     * ```
+     */
+    readonly filePathRegex?: string;
 }
 /** 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>[]> {
@@ -57,6 +69,6 @@ export declare class FlowrSearchElements<Info = NoInfo, Elements extends FlowrSe
      *
      * 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: FlowrAnalysisProvider, enrichment: E, args?: EnrichmentSearchArguments<E>): Promise<this>;
+    enrich<E extends Enrichment>(data: ReadonlyFlowrAnalysisProvider, enrichment: E, args?: EnrichmentSearchArguments<E>): Promise<this>;
     enrichmentContent<E extends Enrichment>(enrichment: E): EnrichmentSearchContent<E>;
 }

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

@@ -1,15 +1,16 @@
 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 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 { Query, QueryResult } from '../../queries/query';
-import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
+import { type CfgSimplificationPassName } from '../../control-flow/cfg-simplification';
 import type { AsyncOrSync } from 'ts-essentials';
-import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { FlowrConfigOptions } from '../../config';
 export interface EnrichmentData<ElementContent extends MergeableRecord, ElementArguments = undefined, SearchContent extends MergeableRecord = never, SearchArguments = ElementArguments> {
     /**
      * A function that is applied to each element of the search to enrich it with additional data.
@@ -18,8 +19,9 @@ export interface EnrichmentData<ElementContent extends MergeableRecord, ElementA
         dataflow: DataflowInformation;
         normalize: NormalizedAst;
         cfg: ControlFlowInformation;
+        config: FlowrConfigOptions;
     }, args: ElementArguments | undefined, previousValue: ElementContent | undefined) => AsyncOrSync<ElementContent>;
-    readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: FlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
+    readonly enrichSearch?: (search: FlowrSearchElements<ParentInformation>, data: ReadonlyFlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
     /**
      * The mapping function used by the {@link Mapper.Enrichment} mapper.
      */
@@ -98,6 +100,7 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: {
             onlyBuiltin?: boolean;
         } | undefined, prev: CallTargetsContent | undefined) => CallTargetsContent;
@@ -108,6 +111,7 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
@@ -116,19 +120,21 @@ export declare const Enrichments: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, _args: CfgInformationArguments | undefined, prev: CfgInformationElementContent | undefined) => {
             isRoot: boolean;
             isReachable: boolean | undefined;
         };
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: FlowrAnalysisProvider, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: CfgInformationArguments | undefined, prev: CfgInformationSearchContent | undefined) => Promise<CfgInformationSearchContent>;
     };
     readonly "query-data": {
         enrichElement: (_e: FlowrSearchElement<ParentInformation>, _search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: {
             dataflow: DataflowInformation;
             normalize: NormalizedAst;
             cfg: ControlFlowInformation;
+            config: FlowrConfigOptions;
         }, args: QueryDataElementContent | undefined, prev: QueryDataElementContent | undefined) => QueryDataElementContent;
-        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: FlowrAnalysisProvider, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
+        enrichSearch: (_search: FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>, _data: ReadonlyFlowrAnalysisProvider<import("../../r-bridge/parser").KnownParser>, args: QueryDataSearchContent | undefined, prev: QueryDataSearchContent | undefined) => Required<QueryDataSearchContent>;
     };
 };
 /**
@@ -138,8 +144,12 @@ 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>;
+/**
+ * Enriches the given search element with the given enrichment type, using the provided analysis data.
+ */
 export declare function enrichElement<Element extends FlowrSearchElement<ParentInformation>, E extends Enrichment>(e: Element, s: FlowrSearchElements<ParentInformation>, data: {
     dataflow: DataflowInformation;
     normalize: NormalizedAst;
     cfg: ControlFlowInformation;
+    config: FlowrConfigOptions;
 }, enrichment: E, args?: EnrichmentElementArguments<E>): Promise<Element>;

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

@@ -7,7 +7,6 @@ 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");
@@ -76,9 +75,8 @@ exports.Enrichments = {
             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.extractCfgQuick)(data.normalize);
                 for (const arg of args) {
-                    const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, cfg.graph, data.dataflow.graph, {
+                    const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, data.cfg.graph, data.dataflow.graph, {
                         ...arg,
                         callName: (0, call_context_query_executor_1.promoteCallName)(arg.callName),
                         type: 'link-to-last-call',
@@ -137,6 +135,9 @@ exports.Enrichments = {
 function enrichmentContent(e, enrichment) {
     return e?.enrichments?.[enrichment];
 }
+/**
+ * Enriches the given search element with the given enrichment type, using the provided analysis data.
+ */
 async function enrichElement(e, s, data, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
     const prev = e?.enrichments;

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

@@ -1,10 +1,11 @@
-import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter } from '../flowr-search';
-import { FlowrSearchElements } from '../flowr-search';
+import { type FlowrSearchElement, type FlowrSearchGeneratorNodeBase, type FlowrSearchGetFilter, FlowrSearchElements } from '../flowr-search';
 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 { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import { type SlicingCriteria } from '../../slicing/criterion/parse';
+import { type Query } from '../../queries/query';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import type TreeSitter from 'web-tree-sitter';
+export declare const searchLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This is a union of all possible generator node types
  */
@@ -24,19 +25,27 @@ export declare const generators: {
     readonly criterion: typeof generateCriterion;
     readonly from: typeof generateFrom;
     readonly 'from-query': typeof generateFromQuery;
+    readonly syntax: typeof generateSyntax;
 };
-declare function generateAll(data: FlowrAnalysisProvider): Promise<FlowrSearchElements<ParentInformation>>;
-declare function generateGet(input: FlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex } }: {
+declare function generateAll(data: ReadonlyFlowrAnalysisProvider): Promise<FlowrSearchElements<ParentInformation>>;
+declare function generateGet(input: ReadonlyFlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex, filePathRegex } }: {
     filter: FlowrSearchGetFilter;
 }): Promise<FlowrSearchElements<ParentInformation>>;
-declare function generateFrom(_input: FlowrAnalysisProvider, args: {
+declare function generateFrom(_input: ReadonlyFlowrAnalysisProvider, args: {
     from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[];
 }): FlowrSearchElements<ParentInformation>;
-declare function generateFromQuery(input: FlowrAnalysisProvider, args: {
+declare function generateFromQuery(input: ReadonlyFlowrAnalysisProvider, args: {
     from: readonly Query[];
 }): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
-declare function generateCriterion(input: FlowrAnalysisProvider, args: {
+declare function generateSyntax(input: ReadonlyFlowrAnalysisProvider, args: {
+    source: TreeSitter.Query | string;
+    captures: readonly string[];
+}): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+declare function generateCriterion(input: ReadonlyFlowrAnalysisProvider, args: {
     criterion: SlicingCriteria;
 }): Promise<FlowrSearchElements<ParentInformation>>;
+/**
+ * Gets the search generator function for the given name
+ */
 export declare function getGenerator<Name extends GeneratorNames>(name: Name): typeof generators[Name];
 export {};

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

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generators = void 0;
+exports.generators = exports.searchLogger = void 0;
 exports.getGenerator = getGenerator;
 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");
+const visitor_1 = require("../../r-bridge/lang-4.x/ast/model/processing/visitor");
+const log_1 = require("../../util/log");
+exports.searchLogger = log_1.log.getSubLogger({ name: 'search' });
 /**
  * All supported generators!
  */
@@ -15,7 +18,8 @@ exports.generators = {
     get: generateGet,
     criterion: generateCriterion,
     from: generateFrom,
-    'from-query': generateFromQuery
+    'from-query': generateFromQuery,
+    syntax: generateSyntax
 };
 async function generateAll(data) {
     return new flowr_search_1.FlowrSearchElements((await getAllNodes(data))
@@ -26,13 +30,18 @@ async function getAllNodes(data) {
     return [...new Map([...normalize.idMap.values()].map(n => [n.info.id, n]))
             .values()];
 }
-async function generateGet(input, { filter: { line, column, id, name, nameIsRegex } }) {
+async function generateGet(input, { filter: { line, column, id, name, nameIsRegex, filePathRegex } }) {
     const normalize = await input.normalize();
     let potentials = (id ?
         [normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
         await getAllNodes(input));
+    if (filePathRegex) {
+        const filePathFilter = new RegExp(filePathRegex);
+        potentials = potentials.filter(({ info }) => info.file && filePathFilter.test(info.file));
+    }
     if (line && line < 0) {
-        const maxLines = normalize.ast.info.fullRange?.[2] ??
+        (0, assert_1.guard)(normalize.ast.files.length === 1, 'Currently, negative line numbers are only supported for single-file inputs');
+        const maxLines = normalize.ast.files[0].root.info.fullRange?.[2] ??
             (id ? (await getAllNodes(input)) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
         line = maxLines + line + 1;
     }
@@ -81,13 +90,56 @@ async function generateFromQuery(input, args) {
         .enrich(input, search_enrichers_1.Enrichment.QueryData, { queries: result });
     return elements.mutate(s => Promise.all(s.map(async (e) => {
         const [query, _] = [...nodesByQuery].find(([_, nodes]) => nodes.has(e));
-        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg }, search_enrichers_1.Enrichment.QueryData, { query });
+        return await (0, search_enrichers_1.enrichElement)(e, elements, { normalize, dataflow, cfg, config: input.flowrConfig }, search_enrichers_1.Enrichment.QueryData, { query });
     })));
 }
+async function generateSyntax(input, args) {
+    // if the user didn't specify a specific capture, we want to capture the outermost item
+    if (!args.captures?.length) {
+        (0, assert_1.guard)(typeof args.source === 'string', `Cannot use default capture name for pre-compiled query ${JSON.stringify(args.source)}, specify captures explicitly`);
+        const defaultCaptureName = 'defaultCapture';
+        args.source += ` @${defaultCaptureName}`;
+        args.captures = [defaultCaptureName];
+    }
+    // allow specifying capture names with or without the @ in front :)
+    const captures = new Set(args.captures.map(c => c.startsWith('@') ? c.substring(1) : c));
+    const info = input.parserInformation();
+    (0, assert_1.guard)(info.name === 'tree-sitter', 'treeSitterQuery can only be used with TreeSitterExecutor parsers!');
+    const result = await info.treeSitterQuery(args.source);
+    const relevant = result.filter(c => captures.has(c.name));
+    if (!relevant.length) {
+        exports.searchLogger.debug(`empty tree-sitter query result for query ${JSON.stringify(args)}`);
+        return new flowr_search_1.FlowrSearchElements([]);
+    }
+    const nodesByTreeSitterId = new Map();
+    (0, visitor_1.visitAst)((await input.normalize()).ast.files.map(f => f.root), node => {
+        const treeSitterInfo = node.info;
+        if (treeSitterInfo.treeSitterId) {
+            nodesByTreeSitterId.set(treeSitterInfo.treeSitterId, node);
+        }
+        else {
+            exports.searchLogger.debug(`normalized ast node ${node.lexeme} with type ${node.type} does not have a tree-sitter id`);
+        }
+    });
+    const ret = [];
+    for (const capture of relevant) {
+        const node = nodesByTreeSitterId.get(capture.node.id);
+        if (node) {
+            ret.push({ node });
+        }
+        else {
+            exports.searchLogger.debug(`tree-sitter node ${capture.node.id} with type ${capture.node.type} does not have a corresponding normalized ast node`);
+        }
+    }
+    return new flowr_search_1.FlowrSearchElements(ret);
+}
 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)) })));
 }
+/**
+ * Gets the search generator function for the given name
+ */
 function getGenerator(name) {
     if (!exports.generators[name]) {
         throw new Error(`Unknown generator: ${name}`);