@eagleoutice/flowr 2.6.2 → 2.7.0

package/r-bridge/retriever.d.ts

@@ -2,24 +2,21 @@ import { type RShell } from './shell';
 import type { AsyncOrSync } from 'ts-essentials';
 import { RShellExecutor } from './shell-executor';
 import { type NormalizedAst } from './lang-4.x/ast/model/processing/decorate';
-import type { SupportedFormats } from '../util/formats/adapter-format';
 export declare const fileProtocol = "file://";
-export interface ParseRequestAdditionalInfoBase {
-    type: SupportedFormats;
-}
-export interface RParseRequestFromFile<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
+export interface RParseRequestFromFile {
     readonly request: 'file';
     /**
-     * The path to the file (an absolute path is probably best here).
+     * The path to the file represented in the {@link FlowrAnalyzerFilesContext}.
      * See {@link RParseRequests} for multiple files.
      */
     readonly content: string;
-    /**
-     * Additional info from different file formates like .Rmd
-     */
-    readonly info?: AdditionalInfo;
 }
-export interface RParseRequestFromText<AdditionalInfo extends ParseRequestAdditionalInfoBase = ParseRequestAdditionalInfoBase> {
+/**
+ * A request to parse R code given as text.
+ * This option is mostly useful for quick tests or injects, as usually files are controlled by the {@link RParseRequestFromFile} request
+ * referring to a file in the {@link FlowrAnalyzerFilesContext}.
+ */
+export interface RParseRequestFromText {
     readonly request: 'text';
     /**
      * Source code to parse (not a file path).
@@ -28,10 +25,6 @@ export interface RParseRequestFromText<AdditionalInfo extends ParseRequestAdditi
      * or concatenate their contents to pass them with this request.
      */
     readonly content: string;
-    /**
-     * Additional info from different file formates like .Rmd
-     */
-    readonly info?: AdditionalInfo;
 }
 /**
  * A provider for an {@link RParseRequests} that can be used, for example, to override source file parsing behavior in tests
@@ -77,6 +70,7 @@ export declare function retrieveParseDataFromRCode(request: RParseRequest, shell
 /**
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows further querying the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ * This function is outdated and should only be used for legacy reasons. Please use the {@link FlowrAnalyzer} instead.
  */
 export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, shell: RShell): Promise<NormalizedAst>;
 /**

package/r-bridge/retriever.js

@@ -23,7 +23,6 @@ const decorate_1 = require("./lang-4.x/ast/model/processing/decorate");
 const type_1 = require("./lang-4.x/ast/model/type");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const adapter_1 = require("../util/formats/adapter");
 exports.fileProtocol = 'file://';
 /**
  * Type guard for {@link RParseRequest}
@@ -39,18 +38,25 @@ function isParseRequest(request) {
  * If your input starts with {@link fileProtocol}, it is assumed to be a file path and will be processed as such.
  * Giving an array, you can mix file paths and text content (again using the {@link fileProtocol}).
  *
+ * To obtain a {@link FlowrAnalyzerContext} from such an input, use {@link contextFromInput}.
  */
-function requestFromInput(input, fileTypeHint) {
+function requestFromInput(input) {
     if (Array.isArray(input)) {
         return input.flatMap(requestFromInput);
     }
     const content = input;
     const file = content.startsWith(exports.fileProtocol);
     if (file) {
-        return (0, adapter_1.requestFromFile)(content.slice(7));
+        return {
+            request: 'file',
+            content: content.substring(exports.fileProtocol.length),
+        };
     }
     else {
-        return (0, adapter_1.requestFromText)(content, fileTypeHint);
+        return {
+            request: 'text',
+            content
+        };
     }
 }
 /**
@@ -134,10 +140,13 @@ function retrieveParseDataFromRCode(request, shell) {
 /**
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows further querying the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ * This function is outdated and should only be used for legacy reasons. Please use the {@link FlowrAnalyzer} instead.
  */
 async function retrieveNormalizedAstFromRCode(request, shell) {
     const data = await retrieveParseDataFromRCode(request, shell);
-    return (0, parser_1.normalize)({ parsed: data }, (0, decorate_1.deterministicCountingIdGenerator)(0), request.request === 'file' ? request.content : undefined);
+    return (0, parser_1.normalize)({
+        files: [{ parsed: data, filePath: request.request === 'file' ? request.content : undefined }]
+    }, (0, decorate_1.deterministicCountingIdGenerator)(0));
 }
 /**
  * If the string has (R-)quotes around it, they will be removed; otherwise the string is returned unchanged.

package/r-bridge/shell.d.ts

@@ -70,7 +70,7 @@ export interface RShellOptions extends RShellSessionOptions {
 }
 export declare const DEFAULT_R_PATH: string;
 /**
- *
+ * Get the default RShell options, possibly using the given config to override some values
  */
 export declare function getDefaultRShellOptions(config?: RShellEngineConfig): RShellOptions;
 /**

package/r-bridge/shell.js

@@ -62,7 +62,7 @@ exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
 exports.DEFAULT_R_PATH = (0, os_1.getPlatform)() === 'windows' ? 'R.exe' : 'R';
 let DEFAULT_R_SHELL_OPTIONS = undefined;
 /**
- *
+ * Get the default RShell options, possibly using the given config to override some values
  */
 function getDefaultRShellOptions(config) {
     if (!DEFAULT_R_SHELL_OPTIONS) {

package/reconstruct/auto-select/auto-select-defaults.d.ts

@@ -6,7 +6,6 @@ import type { ParentInformation, NormalizedAst } from '../../r-bridge/lang-4.x/a
  * independent of if it is selected by the slice or not.
  * @see reconstructToCode
  * @see doNotAutoSelect
- * @see autoSelectLibrary
  */
 export type AutoSelectPredicate = (node: RNode<ParentInformation>, fullAst: NormalizedAst) => boolean;
 /**

package/reconstruct/auto-select/magic-comments.js

@@ -52,7 +52,7 @@ function makeMagicCommentHandler(and) {
         if (!lines) {
             lines = new Set();
             const startLineStack = [];
-            (0, visitor_1.visitAst)(normalizedAst.ast, n => {
+            (0, visitor_1.visitAst)(normalizedAst.ast.files.map(f => f.root), n => {
                 const comments = n.info.additionalTokens;
                 if (!comments) {
                     return;

package/reconstruct/reconstruct.d.ts

@@ -6,19 +6,27 @@
 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>;
+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,25 +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();
@@ -439,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.d.ts

@@ -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>[]> {

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

@@ -10,6 +10,7 @@ import { type CfgSimplificationPassName } from '../../control-flow/cfg-simplific
 import type { AsyncOrSync } from 'ts-essentials';
 import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { FlowrConfigOptions } from '../../config';
 export interface EnrichmentData<ElementContent extends MergeableRecord, ElementArguments = undefined, SearchContent extends MergeableRecord = never, SearchArguments = ElementArguments> {
     /**
      * A function that is applied to each element of the search to enrich it with additional data.
@@ -18,6 +19,7 @@ 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: ReadonlyFlowrAnalysisProvider, args: SearchArguments | undefined, previousValue: SearchContent | undefined) => AsyncOrSync<SearchContent>;
     /**
@@ -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: ReadonlyFlowrAnalysisProvider, 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: ReadonlyFlowrAnalysisProvider, 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>;
     };
 };
 /**
@@ -145,4 +151,5 @@ export declare function enrichElement<Element extends FlowrSearchElement<ParentI
     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',

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

@@ -28,7 +28,7 @@ export declare const generators: {
     readonly syntax: typeof generateSyntax;
 };
 declare function generateAll(data: ReadonlyFlowrAnalysisProvider): Promise<FlowrSearchElements<ParentInformation>>;
-declare function generateGet(input: ReadonlyFlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex } }: {
+declare function generateGet(input: ReadonlyFlowrAnalysisProvider, { filter: { line, column, id, name, nameIsRegex, filePathRegex } }: {
     filter: FlowrSearchGetFilter;
 }): Promise<FlowrSearchElements<ParentInformation>>;
 declare function generateFrom(_input: ReadonlyFlowrAnalysisProvider, args: {

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

@@ -30,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;
     }
@@ -85,7 +90,7 @@ 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) {
@@ -107,7 +112,7 @@ async function generateSyntax(input, args) {
         return new flowr_search_1.FlowrSearchElements([]);
     }
     const nodesByTreeSitterId = new Map();
-    (0, visitor_1.visitAst)((await input.normalize()).ast, node => {
+    (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);

package/slicing/criterion/collect-all.d.ts

@@ -5,8 +5,9 @@
  */
 import type { MergeableRecord } from '../../util/objects';
 import type { SlicingCriteria } from './parse';
-import type { RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ParentInformation, RNodeWithParent } 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 { RProject } from '../../r-bridge/lang-4.x/ast/model/nodes/r-project';
 /**
  * Defines the filter for collecting all possible slicing criteria.
  * @see DefaultAllVariablesFilter
@@ -34,4 +35,4 @@ export interface SlicingCriteriaFilter extends MergeableRecord {
  * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
  * If there are not enough matching nodes within the ast, this will return *no* slicing criteria!
  */
-export declare function collectAllSlicingCriteria<OtherInfo>(ast: RNodeWithParent<OtherInfo>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;
+export declare function collectAllSlicingCriteria<OtherInfo>(ast: RProject<OtherInfo & ParentInformation>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;

package/slicing/criterion/collect-all.js

@@ -12,7 +12,7 @@ const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-fun
 function* collectAllSlicingCriteria(ast, filter) {
     (0, assert_1.guard)(filter.minimumSize >= 1, `Minimum size must be at least 1, but was ${filter.minimumSize}`);
     (0, assert_1.guard)(filter.maximumSize >= filter.minimumSize, `Maximum size must be at least minimum size, but was ${filter.maximumSize} < ${filter.minimumSize}`);
-    const potentialSlicingNodes = filter.collectAll(ast);
+    const potentialSlicingNodes = ast.files.flatMap(f => filter.collectAll(f.root));
     if (potentialSlicingNodes.length < filter.minimumSize) {
         return;
     }

package/slicing/criterion/parse.js

@@ -27,14 +27,14 @@ function slicingCriterionToId(criterion, idMap) {
     if (criterion.startsWith('$')) {
         resolved = (0, node_id_1.normalizeIdToNumberIfPossible)(criterion.substring(1));
     }
-    else if (criterion.includes(':')) {
-        const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId([line, column], idMap);
-    }
     else if (criterion.includes('@')) {
         const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
         resolved = conventionalCriteriaToId(parseInt(line), name, idMap);
     }
+    else if (criterion.includes(':')) {
+        const [line, column] = criterion.split(':').map(c => parseInt(c));
+        resolved = locationToId([line, column], idMap);
+    }
     if (resolved === undefined) {
         throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
     }

package/slicing/static/slice-call.d.ts

@@ -6,11 +6,12 @@ import type { REnvironmentInformation } from '../../dataflow/environments/enviro
 import { type DataflowGraph, type OutgoingEdges } from '../../dataflow/graph/graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
+export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
 /** returns the new threshold hit count */
-export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue): void;
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue, ctx: ReadOnlyFlowrAnalyzerContext): void;
 /** Returns true if we found at least one return edge */
 export declare function handleReturns(from: NodeId, queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -16,12 +16,12 @@ const static_slicer_1 = require("./static-slicer");
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, queue) {
+function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, queue, ctx) {
     // bind with call-local environments during slicing
     const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
     (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
     // lift baseEnv on the same level
-    const activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment);
+    const activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment, ctx);
     const name = callerInfo.name;
     (0, assert_1.guard)(name !== undefined, () => `name of id: ${callerInfo.id} can not be found in id map`);
     const functionCallDefs = (0, resolve_by_name_1.resolveByName)(name, activeEnvironment, identifier_1.ReferenceType.Unknown)?.filter(d => !(0, built_in_1.isBuiltIn)(d.definedAt))?.map(d => d.nodeId) ?? [];
@@ -59,9 +59,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
     }
 }
 /** returns the new threshold hit count */
-function sliceForCall(current, callerInfo, dataflowInformation, queue) {
+function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
     const baseEnvironment = current.baseEnvironment;
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue, ctx);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
         /*

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

@@ -7,11 +7,13 @@ import { type REnvironmentInformation } from '../../dataflow/environments/enviro
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
 import type { DataflowInformation } from '../../dataflow/info';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * 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 ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
@@ -19,7 +21,7 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @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 staticSlice(info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+export declare function staticSlice(ctx: ReadOnlyFlowrAnalyzerContext, info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
 /**
  * Updates the potential addition for the given target node in the visiting queue.
  * This describes vertices that might be added *if* another path reaches them.

package/slicing/static/static-slicer.js

@@ -5,11 +5,9 @@ exports.staticSlice = staticSlice;
 exports.updatePotentialAddition = updatePotentialAddition;
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
-const fingerprint_1 = require("./fingerprint");
 const visiting_queue_1 = require("./visiting-queue");
 const slice_call_1 = require("./slice-call");
 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");
@@ -19,6 +17,7 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * 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 ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
@@ -26,21 +25,21 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @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 staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache) {
+function staticSlice(ctx, info, { 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 ${direction} slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
     let { graph } = info;
     if (direction === _00_slice_1.SliceDirection.Forward) {
-        graph = (0, invert_dfg_1.invertDfg)(graph);
+        graph = (0, invert_dfg_1.invertDfg)(graph, ctx.env.makeCleanEnv());
     }
     const queue = new visiting_queue_1.VisitingQueue(threshold, cache);
     let minNesting = Number.MAX_SAFE_INTEGER;
     const sliceSeedIds = new Set();
     // every node ships the call environment which registers the calling environment
     {
-        const emptyEnv = (0, environment_1.initializeCleanEnvironments)();
-        const basePrint = (0, fingerprint_1.envFingerprint)(emptyEnv);
+        const emptyEnv = ctx.env.makeCleanEnv();
+        const basePrint = ctx.env.getCleanEnvFingerprint();
         for (const { id: startId } of decodedCriteria) {
             queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum nesting of all nodes to only add control dependencies if they are "part" of the current execution
@@ -77,7 +76,7 @@ function staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache
         }
         if (!onlyForSideEffects) {
             if (currentVertex.tag === vertex_1.VertexType.FunctionCall && !currentVertex.onlyBuiltin) {
-                (0, slice_call_1.sliceForCall)(current, currentVertex, info, queue);
+                (0, slice_call_1.sliceForCall)(current, currentVertex, info, queue, ctx);
             }
             const ret = (0, slice_call_1.handleReturns)(id, queue, currentEdges, baseEnvFingerprint, baseEnvironment);
             if (ret) {

package/statistics/features/supported/assignments/assignments.js

@@ -17,7 +17,7 @@ const initialAssignmentInfo = {
 exports.AssignmentOperators = new Set(operators_1.Operators.filter(op => operators_1.OperatorDatabase[op].usedAs === 'assignment'));
 function visitAssignment(info, input) {
     const assignmentStack = [];
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(r => r.root), node => {
         if (node.type !== type_1.RType.BinaryOp || !exports.AssignmentOperators.has(node.operator)) {
             return;
         }

package/statistics/features/supported/control-flow/control-flow.js

@@ -20,10 +20,10 @@ const initialControlflowInfo = {
 };
 function visitIfThenElse(info, input) {
     const ifThenElseStack = [];
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.IfThenElse) {
             if (node.type === type_1.RType.FunctionCall && node.named && node.functionName.content === 'switch') {
-                const initialArg = (0, unpack_argument_1.unpackArgument)(node.arguments[0]);
+                const initialArg = (0, unpack_argument_1.unpackNonameArg)(node.arguments[0]);
                 if (initialArg) {
                     info.switchCase = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.switchCase, initialArg);
                 }

package/statistics/features/supported/data-access/data-access.js

@@ -46,7 +46,7 @@ function visitAccess(info, input) {
     const accessNest = [];
     const accessChain = [];
     const parentRoleCache = new Map();
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.Access) {
             return;
         }

package/statistics/features/supported/defined-functions/defined-functions.js

@@ -45,7 +45,7 @@ function retrieveAllCallsites(input, node, recursiveCalls) {
 function visitDefinitions(info, input) {
     const definitionStack = [];
     const allDefinitions = [];
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.FunctionDefinition) {
             return;
         }

package/statistics/features/supported/expression-list/statistics-expression-list.js

@@ -11,7 +11,7 @@ const initialExpressionListInfo = {
 function visitLists(info, input) {
     let nest = -1; // we start with nesting 0
     let total = 0;
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type === type_1.RType.ExpressionList) {
             nest++;
             total++;