@eagleoutice/flowr 2.3.0 → 2.4.1

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

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enrichments = exports.Enrichment = void 0;
 exports.enrichmentContent = enrichmentContent;
-exports.enrich = enrich;
+exports.enrichElement = enrichElement;
+const objects_1 = require("../../util/objects");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const identify_link_to_last_call_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-last-call-relation");
 const assert_1 = require("../../util/assert");
 const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
 /**
  * An enumeration that stores the names of the available enrichments that can be applied to a set of search elements.
  * See {@link FlowrSearchBuilder.with} for more information on how to apply enrichments.
@@ -17,6 +19,8 @@ var Enrichment;
 (function (Enrichment) {
     Enrichment["CallTargets"] = "call-targets";
     Enrichment["LastCall"] = "last-call";
+    Enrichment["CfgInformation"] = "cfg-information";
+    Enrichment["QueryData"] = "query-data";
 })(Enrichment || (exports.Enrichment = Enrichment = {}));
 /**
  * The registry of enrichments that are currently supported by the search.
@@ -24,7 +28,7 @@ var Enrichment;
  */
 exports.Enrichments = {
     [Enrichment.CallTargets]: {
-        enrich: (e, data, args, prev) => {
+        enrichElement: (e, _s, data, args, prev) => {
             // we don't resolve aliases here yet!
             const content = { targets: [] };
             const callVertex = data.dataflow.graph.getVertex(e.node.info.id);
@@ -65,7 +69,7 @@ exports.Enrichments = {
         mapper: ({ targets }) => targets.map(t => t).filter(t => t.node !== undefined)
     },
     [Enrichment.LastCall]: {
-        enrich: (e, data, args, prev) => {
+        enrichElement: (e, _s, data, args, prev) => {
             (0, assert_1.guard)(args && args.length, `${Enrichment.LastCall} enrichment requires at least one argument`);
             const content = prev ?? { linkedIds: [] };
             const vertex = data.dataflow.graph.get(e.node.info.id);
@@ -86,6 +90,41 @@ exports.Enrichments = {
         },
         mapper: ({ linkedIds }) => linkedIds
     },
+    [Enrichment.CfgInformation]: {
+        enrichElement: (e, search, _data, _args, prev) => {
+            const searchContent = search.enrichmentContent(Enrichment.CfgInformation);
+            return {
+                ...prev,
+                isRoot: searchContent.cfg.graph.rootIds().has(e.node.info.id),
+                isReachable: searchContent.reachableNodes?.has(e.node.info.id)
+            };
+        },
+        enrichSearch: (_search, data, args, prev) => {
+            args = {
+                forceRefresh: false,
+                checkReachable: false,
+                simplificationPasses: cfg_simplification_1.DefaultCfgSimplificationOrder,
+                ...args
+            };
+            // short-circuit if we already have a cfg stored
+            if (!args.forceRefresh && prev?.simpleCfg) {
+                return prev;
+            }
+            const content = {
+                ...prev,
+                cfg: (0, extract_cfg_1.extractCfg)(data.normalize, data.config, data.dataflow.graph, args.simplificationPasses),
+            };
+            if (args.checkReachable) {
+                content.reachableNodes = (0, cfg_simplification_1.cfgFindAllReachable)(content.cfg);
+            }
+            return content;
+        }
+    },
+    [Enrichment.QueryData]: {
+        // the query data enrichment is just a "pass-through" that passes the query data to the underlying search
+        enrichElement: (_e, _search, _data, args, prev) => (args ?? prev),
+        enrichSearch: (_search, _data, args, prev) => (0, objects_1.deepMergeObject)(prev, args)
+    }
 };
 /**
  * Returns the content of the given enrichment type from a {@link FlowrSearchElement}.
@@ -96,14 +135,14 @@ exports.Enrichments = {
 function enrichmentContent(e, enrichment) {
     return e?.enrichments?.[enrichment];
 }
-function enrich(e, data, enrichment, args) {
+function enrichElement(e, s, data, enrichment, args) {
     const enrichmentData = exports.Enrichments[enrichment];
     const prev = e?.enrichments;
     return {
         ...e,
         enrichments: {
             ...prev ?? {},
-            [enrichment]: enrichmentData.enrich(e, data, args, prev?.[enrichment])
+            [enrichment]: enrichmentData.enrichElement?.(e, s, data, args, prev?.[enrichment])
         }
     };
 }

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

@@ -1,10 +1,10 @@
-import type { FlowrSearchElement, FlowrSearchElementFromQuery, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } from '../flowr-search';
+import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } from '../flowr-search';
 import { FlowrSearchElements } from '../flowr-search';
 import type { Pipeline } from '../../core/steps/pipeline/pipeline';
 import type { TailTypesOrUndefined } from '../../util/collections/arrays';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../../slicing/criterion/parse';
-import type { Query } from '../../queries/query';
+import type { SynchronousQuery } from '../../queries/query';
 /**
  * This is a union of all possible generator node types
  */
@@ -33,8 +33,8 @@ declare function generateFrom(data: FlowrSearchInput<Pipeline>, args: {
     from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[];
 }): FlowrSearchElements<ParentInformation>;
 declare function generateFromQuery(data: FlowrSearchInput<Pipeline>, args: {
-    from: readonly Query[];
-}): FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>;
+    from: readonly SynchronousQuery[];
+}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
 declare function generateCriterion(data: FlowrSearchInput<Pipeline>, args: {
     criterion: SlicingCriteria;
 }): FlowrSearchElements<ParentInformation>;

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

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

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

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

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

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

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

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

package/slicing/static/fingerprint.js

@@ -7,7 +7,6 @@ exports.envFingerprint = envFingerprint;
 exports.fingerprint = fingerprint;
 const object_hash_1 = __importDefault(require("object-hash"));
 const environment_1 = require("../../dataflow/environments/environment");
-const built_in_1 = require("../../dataflow/environments/built-in");
 function envFingerprint(env) {
     return (0, object_hash_1.default)(env, {
         algorithm: 'md5',
@@ -15,7 +14,7 @@ function envFingerprint(env) {
         respectFunctionProperties: false,
         respectFunctionNames: false,
         ignoreUnknown: true,
-        replacer: (v) => (v === environment_1.BuiltInEnvironment || v === built_in_1.EmptyBuiltInMemory) ? undefined : v
+        replacer: (v) => (0, environment_1.isDefaultBuiltInEnvironment)(v) ? undefined : v
     });
 }
 function fingerprint(id, envFingerprint, onlyForSideEffects) {

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

@@ -5,11 +5,12 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from '.
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { DataflowGraph, 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';
 /**
  * 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];
 /** returns the new threshold hit count */
-export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowGraph: DataflowGraph, queue: VisitingQueue): void;
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue): 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

@@ -59,9 +59,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
     }
 }
 /** returns the new threshold hit count */
-function sliceForCall(current, callerInfo, dataflowGraph, queue) {
+function sliceForCall(current, callerInfo, dataflowInformation, queue) {
     const baseEnvironment = current.baseEnvironment;
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.baseEnvironment, queue);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
         /*
@@ -69,7 +69,7 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
          * hence, we add a new flag and add all argument values to the queue causing directly
          */
         for (const arg of callerInfo.args) {
-            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph);
+            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowInformation.graph);
         }
         return;
     }

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

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

package/slicing/static/static-slicer.js

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

package/util/collections/arrays.d.ts

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

package/util/collections/arrays.js

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

package/util/containers.d.ts

@@ -17,6 +17,7 @@ export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArg
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
+ * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 export declare function resolveIndicesByName(name: Identifier, environment: REnvironmentInformation): ContainerIndices[] | undefined;

package/util/containers.js

@@ -24,6 +24,7 @@ function getAccessOperands(args) {
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
+ * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 function resolveIndicesByName(name, environment) {

package/util/json.js

@@ -46,12 +46,9 @@ function bigStringify(obj, current, send) {
     if (obj === undefined || obj === null) {
         return current + 'null';
     }
-    else if (obj === environment_1.BuiltInEnvironment) {
+    else if ((0, environment_1.isDefaultBuiltInEnvironment)(obj)) {
         return current + '<BuiltInEnvironment>';
     }
-    else if (obj === environment_1.EmptyBuiltInEnvironment) {
-        return current + '<EmptyBuiltInEnvironment>';
-    }
     else if (Array.isArray(obj)) {
         let str = current + '[';
         for (let i = 0; i < obj.length; i++) {

package/util/mermaid/dfg.js

@@ -6,7 +6,6 @@ exports.graphToMermaid = graphToMermaid;
 exports.graphToMermaidUrl = graphToMermaidUrl;
 exports.diffGraphsToMermaid = diffGraphsToMermaid;
 exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
-const assert_1 = require("../assert");
 const mermaid_1 = require("./mermaid");
 const graph_1 = require("../../dataflow/graph/graph");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
@@ -14,7 +13,6 @@ const identifier_1 = require("../../dataflow/environments/identifier");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const vertex_1 = require("../../dataflow/graph/vertex");
-const environment_1 = require("../../dataflow/environments/environment");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const built_in_1 = require("../../dataflow/environments/built-in");
 /**
@@ -135,7 +133,7 @@ function printEnvironmentToLines(env) {
     if (env === undefined) {
         return ['??'];
     }
-    else if (env.id === environment_1.BuiltInEnvironment.id) {
+    else if (env.builtInEnv) {
         return ['Built-in'];
     }
     const lines = [...printEnvironmentToLines(env.parent), `${env.id}${'-'.repeat(40)}`];
@@ -176,7 +174,10 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} stroke:red,stroke-width:5px; `);
     }
     const edges = mermaid.rootGraph.get((0, node_id_1.normalizeIdToNumberIfPossible)(id), true);
-    (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
+    if (edges === undefined) {
+        mermaid.nodeLines.push('   %% No edges found for ' + id);
+        return;
+    }
     const artificialCdEdges = (info.cds ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
     // eslint-disable-next-line prefer-const
     for (let [target, edge] of [...edges[1], ...artificialCdEdges]) {

package/util/prefix.d.ts

@@ -10,4 +10,4 @@
  * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
  * ```
  */
-export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[]): string | undefined;
+export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[] | MapIterator<string>): string | undefined;

package/util/range.d.ts

@@ -68,3 +68,4 @@ export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc,
  * Checks if the first range is a subset of the second range.
  */
 export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;
+export declare function combineRanges(...ranges: SourceRange[]): SourceRange[];

package/util/range.js

@@ -9,6 +9,7 @@ exports.rangesOverlap = rangesOverlap;
 exports.addRanges = addRanges;
 exports.rangeCompare = rangeCompare;
 exports.rangeIsSubsetOf = rangeIsSubsetOf;
+exports.combineRanges = combineRanges;
 const assert_1 = require("./assert");
 function getRangeStart(p) {
     return p === undefined ? undefined : [p[0], p[1]];
@@ -70,6 +71,9 @@ function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
  * Checks if the first range is a subset of the second range.
  */
 function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
-    return r1sl >= r2sl && r1sc >= r2sc && r1el <= r2el && r1ec <= r2ec;
+    return (r1sl > r2sl || r1sl === r2sl && r1sc >= r2sc) && (r1el < r2el || r1sl === r2sl && r1ec <= r2ec);
+}
+function combineRanges(...ranges) {
+    return ranges.filter(range => !ranges.some(other => range !== other && rangeIsSubsetOf(range, other)));
 }
 //# sourceMappingURL=range.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.3.0';
+const version = '2.4.1';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }