@eagleoutice/flowr 2.6.3 → 2.7.2

package/queries/catalog/files-query/files-query-format.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const files_query_executor_1 = require("./files-query-executor");
+const flowr_file_1 = require("../../../project/context/flowr-file");
+const json_1 = require("../../../util/json");
+const retriever_1 = require("../../../r-bridge/retriever");
+function summarizeObjectWithLimit(obj, limitChars = 500, limitLines = 10) {
+    const str = JSON.stringify(obj, json_1.jsonReplacer, 2);
+    if (str.split('\n').length > limitLines) {
+        const lines = str.split('\n').slice(0, limitLines);
+        return lines.join('\n') + '\n... (truncated)';
+    }
+    else if (str.length > limitChars) {
+        return str.slice(0, limitChars) + '... (truncated)';
+    }
+    else {
+        return str;
+    }
+}
+function rolesFromInput(rolesPart) {
+    return rolesPart
+        .reduce((acc, roleName) => {
+        roleName = roleName.trim();
+        // check if it is one of the values
+        if (Object.values(flowr_file_1.FileRole).includes(roleName)) {
+            acc.valid.push(roleName);
+        }
+        else {
+            acc.invalid.push(roleName);
+        }
+        return acc;
+    }, { valid: [], invalid: [] });
+}
+const rolePrefix = 'role:';
+function filesQueryLineParser(output, line, _config) {
+    let roles = undefined;
+    let input = undefined;
+    if (line.length > 0 && line[0].startsWith(rolePrefix)) {
+        const rolesPart = line[0].slice(rolePrefix.length).split(',');
+        const parseResult = rolesFromInput(rolesPart);
+        if (parseResult.invalid.length > 0) {
+            output.stderr(`Invalid roles: ${parseResult.invalid.map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`
+                + `\nValid roles are: ${Object.values(flowr_file_1.FileRole).map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`);
+        }
+        roles = parseResult.valid;
+        input = line[1];
+    }
+    else if (line.length > 0) {
+        input = line[0];
+    }
+    return { query: [{ type: 'files', roles }], rCode: input };
+}
+function filesQueryCompleter(line, startingNewArg, _config) {
+    const rolesPrefixNotPresent = line.length == 0 || (line.length == 1 && line[0].length < rolePrefix.length);
+    const rolesNotFinished = line.length == 1 && line[0].startsWith(rolePrefix) && !startingNewArg;
+    const endOfRoles = line.length == 1 && startingNewArg || line.length == 2;
+    if (rolesPrefixNotPresent) {
+        return { completions: [`${rolePrefix}`] };
+    }
+    else if (endOfRoles) {
+        return { completions: [retriever_1.fileProtocol] };
+    }
+    else if (rolesNotFinished) {
+        const rolesWithoutPrefix = line[0].slice(rolePrefix.length);
+        const usedRoles = rolesWithoutPrefix.split(',').map(r => r.trim());
+        const allRoles = Object.values(flowr_file_1.FileRole);
+        const unusedRoles = allRoles.filter(r => !usedRoles.includes(r));
+        const lastRole = usedRoles[usedRoles.length - 1];
+        const lastRoleIsUnfinished = !allRoles.includes(lastRole);
+        if (lastRoleIsUnfinished) {
+            return { completions: unusedRoles, argumentPart: lastRole };
+        }
+        else if (unusedRoles.length > 0) {
+            return { completions: [','], argumentPart: '' };
+        }
+        else {
+            return { completions: [' '], argumentPart: '' };
+        }
+    }
+    return { completions: [] };
+}
+exports.FilesQueryDefinition = {
+    executor: files_query_executor_1.executeFileQuery,
+    asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('files', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        result.push(`   ╰ Found ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
+        for (const f of out.files) {
+            result.push(`      ╰ ${(0, ansi_1.bold)(f.path, formatter)}${f.role ? ` [role: ${f.role}]` : ''}:`);
+            const summary = summarizeObjectWithLimit(f.content);
+            for (const line of summary.split('\n')) {
+                result.push(`          ${line}`);
+            }
+        }
+        return true;
+    },
+    completer: filesQueryCompleter,
+    fromLine: filesQueryLineParser,
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('files').required().description('The type of the query.'),
+        roles: joi_1.default.array().optional().items(joi_1.default.string().valid(...Object.values(flowr_file_1.FileRole))).description('Optional roles of the files to query. If not provided, all roles are considered.'),
+        matchesPathRegex: joi_1.default.string().optional().description('An optional regular expression to match the file paths against.')
+    }).description('The file query finds files in the project based on their roles and path patterns.'),
+    flattenInvolvedNodes: (_) => {
+        return [];
+    }
+};
+//# sourceMappingURL=files-query-format.js.map

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -32,11 +32,11 @@ async function executeHigherOrderQuery({ analyzer }, queries) {
         }
     }
     const graph = (await analyzer.dataflow()).graph;
-    const fns = graph.vertices(true)
-        .filter(([, v]) => (0, vertex_1.isFunctionDefinitionVertex)(v) && (filterFor.size === 0 || filterFor.has(v.id)));
+    const fns = graph.verticesOfType(vertex_1.VertexType.FunctionDefinition)
+        .filter(([, v]) => filterFor.size === 0 || filterFor.has(v.id));
     const result = {};
     for (const [id,] of fns) {
-        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph);
+        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph, analyzer.inspectContext());
     }
     return {
         '.meta': {

package/queries/catalog/linter-query/linter-query-format.js

@@ -34,7 +34,7 @@ function linterQueryLineParser(output, line, _config) {
         const rulesPart = line[0].slice(rulesPrefix.length).split(',');
         const parseResult = rulesFromInput(output, rulesPart);
         if (parseResult.invalid.length > 0) {
-            output.stdout(`Invalid linting rule name(s): ${parseResult.invalid.map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`
+            output.stderr(`Invalid linting rule name(s): ${parseResult.invalid.map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`
                 + `\nValid rule names are: ${Object.keys(linter_rules_1.LintingRules).map(r => (0, ansi_1.bold)(r, output.formatter)).join(', ')}`);
         }
         rules = parseResult.valid;

package/queries/catalog/resolve-value-query/resolve-value-query-executor.js

@@ -26,7 +26,7 @@ async function executeResolveValueQuery({ analyzer }, queries) {
         }
         const values = query.criteria
             .map(criteria => (0, parse_1.slicingCriterionToId)(criteria, ast.idMap))
-            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap, resolve: analyzer.flowrConfig.solver.variables }));
+            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap, resolve: analyzer.flowrConfig.solver.variables, ctx: analyzer.inspectContext() }));
         results[key] = {
             values: values
         };

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -30,7 +30,7 @@ async function executeStaticSliceQuery({ analyzer }, queries) {
         }
         const { criteria, noReconstruction, noMagicComments } = query;
         const sliceStart = Date.now();
-        const slice = (0, static_slicer_1.staticSlice)(await analyzer.dataflow(), await analyzer.normalize(), criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, analyzer.flowrConfig.solver.slicer?.threshold);
+        const slice = (0, static_slicer_1.staticSlice)(analyzer.inspectContext(), await analyzer.dataflow(), await analyzer.normalize(), criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, analyzer.flowrConfig.solver.slicer?.threshold);
         const sliceEnd = Date.now();
         if (noReconstruction) {
             results[key] = { slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } } };

package/queries/query.d.ts

@@ -28,10 +28,11 @@ import { type InspectHigherOrderQuery } from './catalog/inspect-higher-order-que
 import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
 import type { ReplOutput } from '../cli/repl/commands/repl-main';
 import type { CommandCompletions } from '../cli/repl/core';
+import type { FilesQuery } from './catalog/files-query/files-query-format';
 /**
  * These are all queries that can be executed from within flowR
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | FilesQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -105,6 +106,14 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
+    readonly files: {
+        readonly executor: typeof import("./catalog/files-query/files-query-executor").executeFileQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly completer: (line: readonly string[], startingNewArg: boolean, _config: FlowrConfigOptions) => CommandCompletions;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"files">;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (_: BaseQueryResult) => NodeId[];
+    };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;

package/queries/query.js

@@ -35,6 +35,7 @@ const control_flow_query_format_1 = require("./catalog/control-flow-query/contro
 const df_shape_query_format_1 = require("./catalog/df-shape-query/df-shape-query-format");
 const inspect_higher_order_query_format_1 = require("./catalog/inspect-higher-order-query/inspect-higher-order-query-format");
 const log_1 = require("../util/log");
+const files_query_format_1 = require("./catalog/files-query/files-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -42,6 +43,7 @@ exports.SupportedQueries = {
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
     'dataflow-lens': dataflow_lens_query_format_1.DataflowLensQueryDefinition,
     'df-shape': df_shape_query_format_1.DfShapeQueryDefinition,
+    'files': files_query_format_1.FilesQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,
@@ -103,7 +105,7 @@ async function executeQueries(data, queries) {
     const results = [];
     for (const [type, group] of entries) {
         try {
-            const result = await Promise.resolve(executeQueriesOfSameType(data, group));
+            const result = await executeQueriesOfSameType(data, group);
             results.push([type, result]);
         }
         catch (e) {

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -102,7 +102,7 @@ export interface Namespace {
      * The namespace attached to the given node
      * (e.g., a namespaced symbol in `x::y`).
      */
-    namespace: NamespaceIdentifier | undefined;
+    namespace?: NamespaceIdentifier;
 }
 /**
  * This subtype of {@link RNode} represents all types of constants

package/r-bridge/lang-4.x/ast/model/processing/decorate.js

@@ -187,7 +187,7 @@ function createFoldForUnaryOp(info) {
         info.idMap.set(id, decorated);
         const opInfo = operand.info;
         opInfo.parent = id;
-        opInfo.role = "unary-operand" /* RoleInParent.UnaryOperand */;
+        opInfo.role = "unary-op" /* RoleInParent.UnaryOperand */;
         decorated.info.file = info.file;
         return decorated;
     };
@@ -208,7 +208,7 @@ function createFoldForAccess(info) {
                     const curInfo = acc.info;
                     curInfo.parent = id;
                     curInfo.index = idx;
-                    curInfo.role = "index-access" /* RoleInParent.IndexAccess */;
+                    curInfo.role = "index-acc" /* RoleInParent.IndexAccess */;
                 }
             }
         }
@@ -223,11 +223,11 @@ function createFoldForForLoop(info) {
         info.idMap.set(id, decorated);
         const varInfo = variable.info;
         varInfo.parent = id;
-        varInfo.role = "for-variable" /* RoleInParent.ForVariable */;
+        varInfo.role = "for-var" /* RoleInParent.ForVariable */;
         const vecInfo = vector.info;
         vecInfo.parent = id;
         vecInfo.index = 1;
-        vecInfo.role = "for-vector" /* RoleInParent.ForVector */;
+        vecInfo.role = "for-vec" /* RoleInParent.ForVector */;
         const bodyInfo = body.info;
         bodyInfo.parent = id;
         bodyInfo.index = 2;
@@ -280,7 +280,7 @@ function createFoldForIfThenElse(info) {
             const otherwiseInfo = otherwise.info;
             otherwiseInfo.parent = id;
             otherwiseInfo.index = 2;
-            otherwiseInfo.role = "if-otherwise" /* RoleInParent.IfOtherwise */;
+            otherwiseInfo.role = "if-other" /* RoleInParent.IfOtherwise */;
         }
         decorated.info.file = info.file;
         return decorated;
@@ -323,7 +323,7 @@ function createFoldForFunctionCall(info) {
                 const argInfo = arg.info;
                 argInfo.parent = id;
                 argInfo.index = idx;
-                argInfo.role = "call-argument" /* RoleInParent.FunctionCallArgument */;
+                argInfo.role = "call-arg" /* RoleInParent.FunctionCallArgument */;
             }
         }
         decorated.info.file = info.file;
@@ -340,12 +340,12 @@ function createFoldForFunctionDefinition(info) {
             const paramInfo = param.info;
             paramInfo.parent = id;
             paramInfo.index = idx++;
-            paramInfo.role = "function-def-param" /* RoleInParent.FunctionDefinitionParameter */;
+            paramInfo.role = "param" /* RoleInParent.FunctionDefinitionParameter */;
         }
         const bodyInfo = body.info;
         bodyInfo.parent = id;
         bodyInfo.index = idx;
-        bodyInfo.role = "function-def-body" /* RoleInParent.FunctionDefinitionBody */;
+        bodyInfo.role = "fun-body" /* RoleInParent.FunctionDefinitionBody */;
         decorated.info.file = info.file;
         return decorated;
     };

package/r-bridge/lang-4.x/ast/model/processing/role.d.ts

@@ -10,29 +10,29 @@ export declare const enum RoleInParent {
     Root = "root",
     IfCondition = "if-cond",
     IfThen = "if-then",
-    IfOtherwise = "if-otherwise",
+    IfOtherwise = "if-other",
     WhileCondition = "while-cond",
     WhileBody = "while-body",
     RepeatBody = "repeat-body",
-    ForVariable = "for-variable",
-    ForVector = "for-vector",
+    ForVariable = "for-var",
+    ForVector = "for-vec",
     ForBody = "for-body",
     FunctionCallName = "call-name",
-    FunctionCallArgument = "call-argument",
-    FunctionDefinitionBody = "function-def-body",
-    FunctionDefinitionParameter = "function-def-param",
+    FunctionCallArgument = "call-arg",
+    FunctionDefinitionBody = "fun-body",
+    FunctionDefinitionParameter = "param",
     ExpressionListChild = "expr-list-child",
     BinaryOperationLhs = "binop-lhs",
     BinaryOperationRhs = "binop-rhs",
     PipeLhs = "pipe-lhs",
     PipeRhs = "pipe-rhs",
-    UnaryOperand = "unary-operand",
+    UnaryOperand = "unary-op",
     ParameterName = "param-name",
     ParameterDefaultValue = "param-value",
     ArgumentName = "arg-name",
     ArgumentValue = "arg-value",
     Accessed = "accessed",
-    IndexAccess = "index-access"
+    IndexAccess = "index-acc"
 }
 /**
  * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.

package/r-bridge/lang-4.x/ast/parser/main/internal/functions/normalize-parameter.js

@@ -34,7 +34,6 @@ function tryNormalizeParameter(data, objs) {
         name: {
             type: type_1.RType.Symbol,
             location, content,
-            namespace: undefined,
             lexeme: content,
             info: {
                 fullRange: location,

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

@@ -483,7 +483,6 @@ function convertTreeNode(node) {
                 name: {
                     type: type_1.RType.Symbol,
                     location: nameRange,
-                    namespace: undefined,
                     content: name.text,
                     lexeme: name.text,
                     info: {

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/control-flow/control-flow.js

@@ -23,7 +23,7 @@ function visitIfThenElse(info, input) {
     (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

@@ -58,7 +58,7 @@ function visitAccess(info, input) {
                 acc = true;
                 break; // we only account for the first one
             }
-            else if (role === "index-access" /* RoleInParent.IndexAccess */) {
+            else if (role === "index-acc" /* RoleInParent.IndexAccess */) {
                 idxAcc = true;
                 break;
             }

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

@@ -84,7 +84,7 @@ function visitCalls(info, input) {
                 hasCallsEdge ? 1 : 0
             ]);
         }
-        classifyArguments(node.arguments.map(e => (0, unpack_argument_1.unpackArgument)(e)), info.args);
+        classifyArguments(node.arguments.map(e => (0, unpack_argument_1.unpackNonameArg)(e)), info.args);
         calls.push(node);
     }, node => {
         // drop again :D

package/statistics/features/supported/variables/variables.js

@@ -7,6 +7,7 @@ const visitor_1 = require("../../../../r-bridge/lang-4.x/ast/model/processing/vi
 const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
 const r_symbol_1 = require("../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
 const statistics_file_1 = require("../../../output/statistics-file");
+const vertex_1 = require("../../../../dataflow/graph/vertex");
 const initialVariableInfo = {
     numberOfVariableUses: 0,
     numberOfDefinitions: 0,
@@ -30,7 +31,7 @@ function visitVariables(info, input) {
             return;
         }
         const [dfNode] = mayNode;
-        if (dfNode.tag === 'variable-definition') {
+        if (dfNode.tag === vertex_1.VertexType.VariableDefinition) {
             info.numberOfDefinitions++;
             const lexeme = node.info.fullLexeme ?? node.lexeme;
             (0, statistics_file_1.appendStatisticsFile)(exports.variables.name, 'definedVariables', [[

package/util/containers.js

@@ -16,7 +16,7 @@ const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 function getAccessOperands(args) {
     const nonEmptyArgs = args.filter(arg => arg !== r_function_call_1.EmptyArgument);
     const accessedArg = nonEmptyArgs.find(arg => arg.info.role === "accessed" /* RoleInParent.Accessed */);
-    const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-access" /* RoleInParent.IndexAccess */);
+    const accessArg = nonEmptyArgs.find(arg => arg.info.role === "index-acc" /* RoleInParent.IndexAccess */);
     return { accessedArg, accessArg };
 }
 /**
@@ -26,7 +26,7 @@ function getAccessOperands(args) {
  * @returns The indicesCollection of the resolved definitions
  */
 function resolveIndicesByName(name, environment) {
-    const definitions = (0, resolve_by_name_1.resolveByName)(name, environment);
+    const definitions = (0, resolve_by_name_1.resolveByNameAnyType)(name, environment);
     return definitions?.flatMap(def => def?.indicesCollection ?? []);
 }
 /**

package/util/files.d.ts

@@ -1,6 +1,5 @@
 import { type PathLike } from 'fs';
 import type { RParseRequestFromFile } from '../r-bridge/retriever';
-import type { FlowrFileProvider } from '../project/context/flowr-file';
 /**
  * Represents a table, identified by a header and a list of rows.
  */
@@ -70,12 +69,6 @@ export declare function readLineByLineSync(filePath: string, onLine: (line: Buff
  * @param directory - The directory whose parent to return
  */
 export declare function getParentDirectory(directory: string): string;
-/**
- * Parses the given file in the 'Debian Control Format'.
- * @param file - The file to parse
- * @returns Map containing the keys and values of the provided file.
- */
-export declare function parseDCF(file: FlowrFileProvider): Map<string, string[]>;
 /**
  * Checks whether the given path-like object is a file that exists on the local filesystem.
  */

package/util/files.js

@@ -44,7 +44,6 @@ exports.writeTableAsCsv = writeTableAsCsv;
 exports.readLineByLine = readLineByLine;
 exports.readLineByLineSync = readLineByLineSync;
 exports.getParentDirectory = getParentDirectory;
-exports.parseDCF = parseDCF;
 exports.isFilePath = isFilePath;
 const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -201,46 +200,6 @@ function getParentDirectory(directory) {
     // apparently this is somehow the best way to do it in node, what
     return directory.split(path_1.default.sep).slice(0, -1).join(path_1.default.sep);
 }
-/**
- * Parses the given file in the 'Debian Control Format'.
- * @param file - The file to parse
- * @returns Map containing the keys and values of the provided file.
- */
-function parseDCF(file) {
-    const result = new Map();
-    let currentKey = '';
-    let currentValue = '';
-    const indentRegex = new RegExp(/^\s/);
-    const firstColonRegex = new RegExp(/:(.*)/s);
-    const fileContent = file.content().toString().split(/\r?\n/);
-    for (const line of fileContent) {
-        if (indentRegex.test(line)) {
-            currentValue += '\n' + line.trim();
-        }
-        else {
-            if (currentKey) {
-                const values = currentValue ? cleanValues(currentValue) : [];
-                result.set(currentKey, values);
-            }
-            const [key, rest] = line.split(firstColonRegex).map(s => s.trim());
-            currentKey = key.trim();
-            currentValue = rest.trim();
-        }
-    }
-    if (currentKey) {
-        const values = currentValue ? cleanValues(currentValue) : [];
-        result.set(currentKey, values);
-    }
-    return result;
-}
-const cleanSplitRegex = /[\n,]+/;
-const cleanQuotesRegex = /'/g;
-function cleanValues(values) {
-    return values
-        .split(cleanSplitRegex)
-        .map(s => s.trim().replace(cleanQuotesRegex, ''))
-        .filter(s => s.length > 0);
-}
 /**
  * Checks whether the given path-like object is a file that exists on the local filesystem.
  */

package/util/mermaid/ast.d.ts

@@ -1,10 +1,11 @@
 import type { ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RProject } from '../../r-bridge/lang-4.x/ast/model/nodes/r-project';
+import type { MermaidGraphPrinterInfo } from './info';
 /**
  * Serialize the normalized AST to mermaid format
  */
-export declare function normalizedAstToMermaid(ast: RProject<ParentInformation> | RNodeWithParent, prefix?: string): string;
+export declare function normalizedAstToMermaid(ast: RProject<ParentInformation> | RNodeWithParent, { prefix, markStyle, includeOnlyIds, mark }?: MermaidGraphPrinterInfo): string;
 /**
  * Use mermaid to visualize the normalized AST.
  */
-export declare function normalizedAstToMermaidUrl(ast: RProject<ParentInformation> | RNodeWithParent, prefix?: string): string;
+export declare function normalizedAstToMermaidUrl(ast: RProject<ParentInformation> | RNodeWithParent, info?: MermaidGraphPrinterInfo): string;