@eagleoutice/flowr 2.2.10 → 2.2.12

package/queries/catalog/location-map-query/location-map-query-format.js

@@ -14,7 +14,11 @@ exports.LocationMapQueryDefinition = {
     asciiSummarizer: (formatter, _processed, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('location-map', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...Object.keys(out.map)])}}`);
+        result.push('   ╰ File List:');
+        for (const [id, file] of Object.entries(out.map.files)) {
+            result.push(`      ╰ ${id}: \`${file}\``);
+        }
+        result.push(`   ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...Object.keys(out.map.ids)])}}`);
         return true;
     },
     schema: joi_1.default.object({

package/queries/catalog/project-query/project-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectQuery, ProjectQueryResult } from './project-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeProjectQuery({ dataflow }: BasicQueryData, queries: readonly ProjectQuery[]): ProjectQueryResult;

package/queries/catalog/project-query/project-query-executor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeProjectQuery = executeProjectQuery;
+const log_1 = require("../../../util/log");
+function executeProjectQuery({ dataflow }, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+    }
+    return {
+        '.meta': {
+            /* there is no sense in measuring a get */
+            timing: 0
+        },
+        files: dataflow.graph.sourced
+    };
+}
+//# sourceMappingURL=project-query-executor.js.map

package/queries/catalog/project-query/project-query-format.d.ts

@@ -0,0 +1,67 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import { executeProjectQuery } from './project-query-executor';
+import Joi from 'joi';
+export interface ProjectQuery extends BaseQueryFormat {
+    readonly type: 'project';
+}
+export interface ProjectQueryResult extends BaseQueryResult {
+    readonly files: (string | '<inline>')[];
+}
+export declare const ProjectQueryDefinition: {
+    readonly executor: typeof executeProjectQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../../../r-bridge/parser").ParseStepOutput<string>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../r-bridge/parser").ParseStepOutput<string>, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../r-bridge/parser").ParseStepOutput<string>;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+            parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectQueryDefinition = void 0;
+const project_query_executor_1 = require("./project-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+exports.ProjectQueryDefinition = {
+    executor: project_query_executor_1.executeProjectQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('project', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ Contains ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
+        for (const file of out.files) {
+            result.push(`      ╰ \`${file}\``);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('project').required().description('The type of the query.'),
+    }).description('The project query provides information on the analyzed project.')
+};
+//# sourceMappingURL=project-query-format.js.map

package/queries/query.d.ts

@@ -19,7 +19,8 @@ import type { SearchQuery } from './catalog/search-query/search-query-format';
 import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
 import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
 import type { DataflowLensQuery } from './catalog/dataflow-lens-query/dataflow-lens-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery;
+import type { ProjectQuery } from './catalog/project-query/project-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -686,6 +687,64 @@ export declare const SupportedQueries: {
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly project: {
+        readonly executor: typeof import("./catalog/project-query/project-query-executor").executeProjectQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = ReturnType<typeof SupportedQueries[Type]['executor']>;

package/queries/query.js

@@ -27,6 +27,7 @@ const search_query_format_1 = require("./catalog/search-query/search-query-forma
 const happens_before_query_format_1 = require("./catalog/happens-before-query/happens-before-query-format");
 const resolve_value_query_format_1 = require("./catalog/resolve-value-query/resolve-value-query-format");
 const dataflow_lens_query_format_1 = require("./catalog/dataflow-lens-query/dataflow-lens-query-format");
+const project_query_format_1 = require("./catalog/project-query/project-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -41,7 +42,8 @@ exports.SupportedQueries = {
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
     'search': search_query_format_1.SearchQueryDefinition,
     'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition,
-    'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition
+    'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition,
+    'project': project_query_format_1.ProjectQueryDefinition
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/r-bridge/data/data.d.ts

@@ -149,7 +149,7 @@ export declare const flowrCapabilities: {
                 }, {
                     readonly name: "Resolve Arguments";
                     readonly id: "resolve-arguments";
-                    readonly supported: "partially";
+                    readonly supported: "fully";
                     readonly description: "_Correctly bind arguments (including [`pmatch`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/pmatch))._ Currently, we do not have a correct implementation for `pmatch`. Furthermore, more tests would be nice.";
                 }, {
                     readonly name: "Side-Effects in Argument";
@@ -418,7 +418,7 @@ export declare const flowrCapabilities: {
                 }, {
                     readonly name: "Internal and Primitive Functions";
                     readonly id: "built-in-internal-and-primitive-functions";
-                    readonly supported: "not";
+                    readonly supported: "partially";
                     readonly description: "_Handle `.Internal`, `.Primitive`, ..._ In general we can not handle them as they refer to non-R code. We currently do not support them when used with the function.";
                 }, {
                     readonly name: "Options";

package/r-bridge/data/data.js

@@ -200,7 +200,7 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                 {
                                     name: 'Resolve Arguments',
                                     id: 'resolve-arguments',
-                                    supported: 'partially',
+                                    supported: 'fully',
                                     description: '_Correctly bind arguments (including [`pmatch`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/pmatch))._ Currently, we do not have a correct implementation for `pmatch`. Furthermore, more tests would be nice.'
                                 },
                                 {
@@ -532,7 +532,7 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                 {
                                     name: 'Internal and Primitive Functions',
                                     id: 'built-in-internal-and-primitive-functions',
-                                    supported: 'not',
+                                    supported: 'partially',
                                     description: '_Handle `.Internal`, `.Primitive`, ..._ In general we can not handle them as they refer to non-R code. We currently do not support them when used with the function.'
                                 },
                                 {

package/slicing/static/fingerprint.js

@@ -9,7 +9,14 @@ 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, { excludeKeys: key => key === 'id', replacer: (v) => (v === environment_1.BuiltInEnvironment || v === built_in_1.EmptyBuiltInMemory) ? undefined : v });
+    return (0, object_hash_1.default)(env, {
+        algorithm: 'md5',
+        excludeKeys: key => key === 'id' || key === 'value',
+        respectFunctionProperties: false,
+        respectFunctionNames: false,
+        ignoreUnknown: true,
+        replacer: (v) => (v === environment_1.BuiltInEnvironment || v === built_in_1.EmptyBuiltInMemory) ? undefined : v
+    });
 }
 function fingerprint(id, envFingerprint, onlyForSideEffects) {
     return `${id}-${envFingerprint}-${onlyForSideEffects ? '0' : '1'}`;

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

@@ -8,7 +8,7 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
+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;
 /** Returns true if we found at least one return edge */

package/slicing/static/slice-call.js

@@ -16,7 +16,7 @@ const static_slicer_1 = require("./static-slicer");
 /**
  * Returns the function call targets (definitions) by the given caller
  */
-function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment) {
+function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, queue) {
     // 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`);
@@ -30,7 +30,7 @@ function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment) {
             functionCallDefs.push(target);
         }
     }
-    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
+    const functionCallTargets = queue.memoizeCallTargets(functionCallDefs.join(';'), () => (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph));
     return [functionCallTargets, activeEnvironment];
 }
 function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
@@ -38,22 +38,11 @@ function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironm
     if (!valueRoot) {
         return;
     }
-    const callTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set([valueRoot]), dataflowGraph);
+    const callTargets = queue.memoizeCallTargets(valueRoot, () => (0, linker_1.getAllLinkedFunctionDefinitions)(new Set([valueRoot]), dataflowGraph));
     linkCallTargets(false, callTargets, activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
 }
 function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue) {
     for (const functionCallTarget of functionCallTargets) {
-        // all those linked within the scopes of other functions are already linked when exiting a function definition
-        /* for(const openIn of (functionCallTarget as DataflowGraphVertexFunctionDefinition).subflow.in) {
-            // only if the outgoing path does not already have a defined by linkage
-            const defs = openIn.name ? resolveByName(openIn.name, activeEnvironment, openIn.type) : undefined;
-            if(defs === undefined) {
-                continue;
-            }
-            for(const def of defs.filter(d => d.nodeId !== BuiltIn)) {
-                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, onlyForSideEffects);
-            }
-        }*/
         for (const exitPoint of functionCallTarget.exitPoints) {
             queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
         }
@@ -62,7 +51,7 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
 /** returns the new threshold hit count */
 function sliceForCall(current, callerInfo, dataflowGraph, queue) {
     const baseEnvironment = current.baseEnvironment;
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.baseEnvironment);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.baseEnvironment, queue);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
         /*
@@ -91,7 +80,7 @@ function handleReturns(from, queue, currentEdges, baseEnvFingerprint, baseEnviro
             queue.add(target, baseEnvironment, baseEnvFingerprint, false);
         }
         else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.DefinesOnCall | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Argument)) {
-            (0, static_slicer_1.updatePotentialAddition)(queue, from, target, baseEnvironment);
+            (0, static_slicer_1.updatePotentialAddition)(queue, from, target, baseEnvironment, baseEnvFingerprint);
         }
     }
     return true;

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

@@ -9,6 +9,8 @@ export interface NodeToSlice {
     readonly id: NodeId;
     /** used for calling context, etc. */
     readonly baseEnvironment: REnvironmentInformation;
+    /** the fingerprint of the environment */
+    readonly envFingerprint: string;
     /** if we add a function call, we may need it only for its side effects (e.g., a redefinition of a global variable), if so, 'returns' links will not be traced */
     readonly onlyForSideEffects: boolean;
 }

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

@@ -1,4 +1,5 @@
 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';
@@ -15,6 +16,7 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criterias to slice on.
  * @param 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): Readonly<SliceResult>;
-export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation): void;
+export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, 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

@@ -12,6 +12,7 @@ const parse_1 = require("../criterion/parse");
 const environment_1 = require("../../dataflow/environments/environment");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const edge_1 = require("../../dataflow/graph/edge");
+const config_1 = require("../../config");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
  * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
@@ -22,12 +23,13 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
  * @param criteria  - The criterias to slice on.
  * @param 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) {
+function staticSlicing(graph, { idMap }, criteria, threshold = (0, config_1.getConfig)().solver.slicer?.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(', ')}`);
-    const queue = new visiting_queue_1.VisitingQueue(threshold);
+    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
@@ -44,15 +46,15 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
          * include all the implicit side effects that we have to consider as we are unable to narrow them down
          */
         for (const id of graph.unknownSideEffects) {
-            if (typeof id !== 'object') { /* otherwise, their target is just missing */
+            if (typeof id !== 'object') {
+                /* otherwise, their target is just missing */
                 queue.add(id, emptyEnv, basePrint, true);
             }
         }
     }
     while (queue.nonEmpty()) {
         const current = queue.next();
-        const { baseEnvironment, id, onlyForSideEffects } = current;
-        const baseEnvFingerprint = (0, fingerprint_1.envFingerprint)(baseEnvironment);
+        const { baseEnvironment, id, onlyForSideEffects, envFingerprint: baseEnvFingerprint } = current;
         const currentInfo = graph.get(id, true);
         if (currentInfo === undefined) {
             exports.slicerLogger.warn(`id: ${id} must be in graph but can not be found, keep in slice to be sure`);
@@ -78,29 +80,32 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             }
         }
         for (const [target, { types }] of currentEdges) {
-            if ((0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.NonStandardEvaluation)) {
-                continue;
-            }
             const t = (0, edge_1.shouldTraverseEdge)(types);
-            if (t === 3 /* TraverseEdge.Always */) {
-                queue.add(target, baseEnvironment, baseEnvFingerprint, false);
-            }
-            else if (t === 2 /* TraverseEdge.OnlyIfBoth */) {
-                updatePotentialAddition(queue, id, target, baseEnvironment);
-            }
-            else if (t === 1 /* TraverseEdge.SideEffect */) {
-                queue.add(target, baseEnvironment, baseEnvFingerprint, true);
+            switch (t) {
+                case 0 /* TraverseEdge.Never */:
+                    continue;
+                case 3 /* TraverseEdge.Always */:
+                    queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+                    continue;
+                case 2 /* TraverseEdge.OnlyIfBoth */:
+                    updatePotentialAddition(queue, id, target, baseEnvironment, baseEnvFingerprint);
+                    continue;
+                case 1 /* TraverseEdge.SideEffect */:
+                    queue.add(target, baseEnvironment, baseEnvFingerprint, true);
+                    continue;
+                default:
+                    (0, assert_1.assertUnreachable)(t);
             }
         }
     }
     return { ...queue.status(), decodedCriteria };
 }
-function updatePotentialAddition(queue, id, target, baseEnvironment) {
+function updatePotentialAddition(queue, id, target, baseEnvironment, envFingerprint) {
     const n = queue.potentialAdditions.get(target);
     if (n) {
         const [addedBy, { baseEnvironment, onlyForSideEffects }] = n;
         if (addedBy !== id) {
-            queue.add(target, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), onlyForSideEffects);
+            queue.add(target, baseEnvironment, envFingerprint, onlyForSideEffects);
             queue.potentialAdditions.delete(target);
         }
     }
@@ -108,6 +113,7 @@ function updatePotentialAddition(queue, id, target, baseEnvironment) {
         queue.potentialAdditions.set(target, [id, {
                 id: target,
                 baseEnvironment,
+                envFingerprint,
                 onlyForSideEffects: false
             }]);
     }

package/slicing/static/visiting-queue.d.ts

@@ -1,14 +1,19 @@
+import type { Fingerprint } from './fingerprint';
 import type { NodeToSlice, SliceResult } from './slicer-types';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowGraphVertexInfo } from '../../dataflow/graph/vertex';
 export declare class VisitingQueue {
     private readonly threshold;
     private timesHitThreshold;
     private readonly seen;
+    private readonly seenByCache;
     private readonly idThreshold;
     private readonly queue;
+    private readonly cache?;
     potentialAdditions: Map<NodeId, [NodeId, NodeToSlice]>;
-    constructor(threshold: number);
+    private cachedCallTargets;
+    constructor(threshold: number, cache?: Map<Fingerprint, Set<NodeId>>);
     /**
      * Adds a node to the queue if it has not been seen before.
      * @param target             - the node to add
@@ -20,5 +25,6 @@ export declare class VisitingQueue {
     next(): NodeToSlice;
     nonEmpty(): boolean;
     hasId(id: NodeId): boolean;
+    memoizeCallTargets(id: NodeId, targets: () => Set<DataflowGraphVertexInfo>): Set<DataflowGraphVertexInfo>;
     status(): Readonly<Pick<SliceResult, 'timesHitThreshold' | 'result'>>;
 }

package/slicing/static/visiting-queue.js

@@ -2,19 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisitingQueue = void 0;
 const fingerprint_1 = require("./fingerprint");
-const static_slicer_1 = require("./static-slicer");
-const assert_1 = require("../../util/assert");
 class VisitingQueue {
     threshold;
     timesHitThreshold = 0;
     seen = new Map();
+    seenByCache = new Set();
     idThreshold = new Map();
     queue = [];
+    cache = new Map();
     // the set of potential additions holds nodes which may be added if a second edge deems them relevant (e.g., found with the `defined-by-on-call` edge)
     // additionally it holds which node id added the addition so we can separate their inclusion on the structure
     potentialAdditions = new Map();
-    constructor(threshold) {
+    cachedCallTargets = new Map();
+    constructor(threshold, cache) {
         this.threshold = threshold;
+        this.cache = cache;
     }
     /**
      * Adds a node to the queue if it has not been seen before.
@@ -26,16 +28,22 @@ class VisitingQueue {
     add(target, env, envFingerprint, onlyForSideEffects) {
         const idCounter = this.idThreshold.get(target) ?? 0;
         if (idCounter > this.threshold) {
-            static_slicer_1.slicerLogger.warn(`id: ${target} has been visited ${idCounter} times, skipping`);
             this.timesHitThreshold++;
             return;
         }
         /* we do not include the in call part in the fingerprint as it is 'deterministic' from the source position */
         const print = (0, fingerprint_1.fingerprint)(target, envFingerprint, onlyForSideEffects);
         if (!this.seen.has(print)) {
+            const cached = this.cache?.get(print);
+            if (cached) {
+                this.seenByCache.add(target);
+                for (const id of cached) {
+                    this.queue.push({ id, baseEnvironment: env, envFingerprint, onlyForSideEffects });
+                }
+            }
             this.idThreshold.set(target, idCounter + 1);
             this.seen.set(print, target);
-            this.queue.push({ id: target, baseEnvironment: env, onlyForSideEffects });
+            this.queue.push({ id: target, baseEnvironment: env, envFingerprint, onlyForSideEffects });
         }
     }
     next() {
@@ -47,10 +55,16 @@ class VisitingQueue {
     hasId(id) {
         return this.idThreshold.has(id);
     }
+    memoizeCallTargets(id, targets) {
+        if (!this.cachedCallTargets.has(id)) {
+            this.cachedCallTargets.set(id, targets());
+        }
+        return this.cachedCallTargets.get(id);
+    }
     status() {
         return {
             timesHitThreshold: this.timesHitThreshold,
-            result: new Set([...this.seen.values()].filter(assert_1.isNotUndefined))
+            result: new Set([...this.seen.values(), ...this.seenByCache])
         };
     }
 }

package/util/arrays.d.ts

@@ -65,3 +65,26 @@ export declare function arraySum(arr: readonly number[]): number;
  */
 export declare function array2bag<T>(arr: T[]): Map<T, number>;
 export declare function arrayEqual<T>(a: readonly T[] | undefined, b: readonly T[] | undefined): boolean;
+/**
+ * Samples elements from a list such that the distance between the sampled elements is as equal as possible.
+ *
+ * If the number of elements to sample is greater or equal to the number of elements in the list, the list is returned as is.
+ * If the number of elements to sample is less than or equal to 0, an empty list is returned.
+ *
+ * @param list - list of elements
+ * @param sampleCount - number of elements to sample
+ * @param rounding - rounding mode to use for the index calculation
+ * @returns - a list of elements equidistantly sampled from the input list
+ */
+export declare function equidistantSampling<T>(list: readonly T[], sampleCount: number, rounding?: 'floor' | 'ceil'): T[];
+/**
+ * Returns the cartesian product of the given arrays.
+ * @example
+ *
+ * ```ts
+ * cartesianProduct([1, 2], ['a', 'b', 'c'], [true, false])
+ * // -> [[1, 'a', true], [1, 'a', false], [1, 'b', true], [1, 'b', false], [1, 'c', true], [1, 'c', false], [2, 'a', true], [2, 'a', false], [2, 'b', true], [2, 'b', false], [2, 'c', true], [2, 'c', false]]
+ * ```
+ *
+ */
+export declare function cartesianProduct<T>(...arrays: T[][]): T[][];