@eagleoutice/flowr 2.9.14 → 2.10.1

package/queries/catalog/input-sources-query/input-sources-query-format.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputSourcesDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+const joi_1 = __importDefault(require("joi"));
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+const input_sources_query_executor_1 = require("./input-sources-query-executor");
+const range_1 = require("../../../util/range");
+function inputSourcesQueryLineParser(output, line, _config) {
+    const criterion = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    if (!criterion || criterion.length !== 1) {
+        output.stderr(output.formatter.format('Invalid provenance query format, a single slicing criterion must be given in the form "(criterion1)"', { color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }));
+        return { query: [] };
+    }
+    return { query: [{
+                type: 'input-sources',
+                criterion: criterion[0],
+            }], rCode: line[1] };
+}
+exports.InputSourcesDefinition = {
+    executor: input_sources_query_executor_1.executeInputSourcesQuery,
+    asciiSummarizer: async (formatter, analyzer, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('input-sources', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        const nast = (await analyzer.normalize()).idMap;
+        for (const [key, sources] of Object.entries(out.results)) {
+            result.push(`   ╰ Input Sources for ${key}`);
+            for (const { id, trace, type } of sources) {
+                const kNode = nast.get(id);
+                const kLoc = kNode ? range_1.SourceLocation.format(range_1.SourceLocation.fromNode(kNode)) : 'unknown location';
+                result.push(`           ╰ ${kLoc} (id: ${id}), type: ${JSON.stringify(type)}, trace: ${trace}`);
+            }
+        }
+        return true;
+    },
+    fromLine: inputSourcesQueryLineParser,
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('input-sources').required().description('The type of the query.'),
+        criterion: joi_1.default.string().required().description('The slicing criterion to use.'),
+        config: joi_1.default.object({
+            networkFunctions: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that fetch data from the network.'),
+            randomnessConsumers: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that consume randomness.'),
+            randomnessProducers: joi_1.default.array().items(joi_1.default.object({ type: joi_1.default.string().valid('function', 'assignment'), name: joi_1.default.string().required() })).optional().description('Functions or assignments that produce randomness seeds.'),
+            configurableFunctions: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that read configuration (options/env).'),
+            pureFunctions: joi_1.default.array().items(joi_1.default.string()).optional().description('Deterministic functions that keep constant inputs constant.'),
+        }).optional()
+    }).description('Input Sources query definition'),
+    flattenInvolvedNodes: (queryResults) => {
+        const flattened = [];
+        const out = queryResults;
+        for (const obj of Object.values(out.results)) {
+            for (const e of obj) {
+                flattened.push(e.id);
+            }
+        }
+        return flattened;
+    }
+};
+//# sourceMappingURL=input-sources-query-format.js.map

package/queries/catalog/input-sources-query/simple-input-classifier.d.ts

@@ -0,0 +1,90 @@
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { MergeableRecord } from '../../../util/objects';
+import { Identifier } from '../../../dataflow/environments/identifier';
+/**
+ * Lattice flattening until we have a taint engine :)
+ *
+ *```
+ *            [ Unknown ]
+ *     /     /     |     \       \
+ *[Param] [File] [Net] [Rand] [Scope]
+ *     \     \    |      /      /
+ *        [ DerivedConstant ]
+ *               |
+ *          [ Constant ]
+ *```
+ *
+ */
+export declare enum InputType {
+    Parameter = "param",
+    File = "file",
+    Network = "net",
+    Random = "rand",
+    Constant = "const",
+    /** Read from environment/call scope */
+    Scope = "scope",
+    /** Pure calculations from constants that lead to a constant */
+    DerivedConstant = "dconst",
+    Unknown = "unknown"
+}
+export declare enum InputTraceType {
+    /** Derived only from aliasing */
+    Alias = "alias",
+    /** Derived from pure function chains */
+    Pure = "pure",
+    /** Derived from known but not necessarily all pure function chains */
+    Known = "known",
+    /** Not fully known origin */
+    Unknown = "unknown"
+}
+/**
+ * Object attached to an input source
+ * @see {@link InputSources}
+ */
+export interface InputSource extends MergeableRecord {
+    id: NodeId;
+    type: InputType[];
+    trace: InputTraceType;
+    /** if the trace is affected by control dependencies, they are classified too, this is a duplicate free array */
+    cds?: InputType[];
+}
+/**
+ * Map of input sources, keyed by the node id of the input source. Each input source is classified with an {@link InputSource} object.
+ */
+export type InputSources = InputSource[];
+/**
+ * This is either an {@link NodeId|id} of a known functions all of that category (e.g., you can issue a dependencies query before and then pass all
+ * identified ids to this query here).
+ */
+export type InputClassifierFunctionIdentifier = Identifier | NodeId;
+/**
+ * For the specifications of `pureFns` etc. please have a look at {@link InputClassifierFunctionIdentifier}.
+ */
+export interface InputClassifierConfig extends MergeableRecord {
+    /**
+     * Functions which are considered to be pure (i.e., deterministic, trusted, safe, idempotent on the lub of the input types)
+     */
+    pureFns: readonly InputClassifierFunctionIdentifier[];
+    /**
+     * Functions that read from the network
+     */
+    networkFns: readonly InputClassifierFunctionIdentifier[];
+    /**
+     * Functions that produce a random value
+     * Note: may need to check with respect to seeded randomness
+     */
+    randomFns: readonly InputClassifierFunctionIdentifier[];
+    /**
+     * Functions that read from the file system
+     */
+    readFileFns: readonly InputClassifierFunctionIdentifier[];
+}
+/**
+ * Takes the given id which is expected to either be:
+ * - a function call - in this case all arguments are considered to be inputs (additionally to all read edges from the function call in the dataflow graph)
+ * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you pased in.
+ *
+ * This method traces the dependencies in the dataflow graph using the specification of functions passed in
+ */
+export declare function classifyInput(id: NodeId, dfg: DataflowGraph, config: InputClassifierConfig): InputSources;

package/queries/catalog/input-sources-query/simple-input-classifier.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputTraceType = exports.InputType = void 0;
+exports.classifyInput = classifyInput;
+const graph_1 = require("../../../dataflow/graph/graph");
+const objects_1 = require("../../../util/objects");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
+const identifier_1 = require("../../../dataflow/environments/identifier");
+const assert_1 = require("../../../util/assert");
+const arrays_1 = require("../../../util/collections/arrays");
+const built_in_proc_name_1 = require("../../../dataflow/environments/built-in-proc-name");
+class InputClassifier {
+    dfg;
+    config;
+    cache = new Map();
+    constructor(dfg, config) {
+        this.dfg = dfg;
+        this.config = config;
+    }
+    classifyEntry(vertex) {
+        const cached = this.cache.get(vertex.id);
+        if (cached) {
+            return cached;
+        }
+        // insert temporary unknown to break cycles
+        this.cache.set(vertex.id, { id: vertex.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+        switch (vertex.tag) {
+            case vertex_1.VertexType.Value:
+                return this.classifyCdsAndReturn(vertex, { id: vertex.id, type: [InputType.Constant], trace: InputTraceType.Unknown });
+            case vertex_1.VertexType.FunctionCall:
+                return this.classifyFunctionCall(vertex);
+            case vertex_1.VertexType.VariableDefinition:
+                return this.classifyVariableDefinition(vertex);
+            case vertex_1.VertexType.Use:
+                return this.classifyVariable(vertex);
+            default:
+                return this.classifyCdsAndReturn(vertex, { id: vertex.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+        }
+    }
+    classifyFunctionCall(call) {
+        if (call.origin.includes(built_in_proc_name_1.BuiltInProcName.IfThenElse) || call.origin.includes(built_in_proc_name_1.BuiltInProcName.WhileLoop)) {
+            const condition = graph_1.FunctionArgument.getReference(call.args[0]);
+            if (condition) {
+                const vtx = this.dfg.getVertex(condition);
+                if (vtx) {
+                    return this.classifyCdsAndReturn(call, this.classifyEntry(vtx));
+                }
+            }
+        }
+        else if (call.origin.includes(built_in_proc_name_1.BuiltInProcName.ForLoop)) {
+            const condition = graph_1.FunctionArgument.getReference(call.args[1]);
+            if (condition) {
+                const vtx = this.dfg.getVertex(condition);
+                if (vtx) {
+                    return this.classifyCdsAndReturn(call, this.classifyEntry(vtx));
+                }
+            }
+        }
+        if (!matchesList(call, this.config.pureFns)) {
+            if (matchesList(call, this.config.readFileFns)) {
+                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.File], trace: InputTraceType.Unknown });
+            }
+            else if (matchesList(call, this.config.networkFns)) {
+                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Network], trace: InputTraceType.Unknown });
+            }
+            else if (matchesList(call, this.config.randomFns)) {
+                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Random], trace: InputTraceType.Unknown });
+            }
+            else {
+                // if it is not pure, we cannot classify based on the inputs, in that case we do not know!
+                return this.classifyCdsAndReturn(call, { id: call.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+            }
+        }
+        // Otherwise, classify by arguments; pure functions get Known/Pure handling
+        const argTypes = [];
+        const cdTypes = [];
+        for (const arg of call.args) {
+            if (graph_1.FunctionArgument.isEmpty(arg)) {
+                continue;
+            }
+            const ref = graph_1.FunctionArgument.getReference(arg);
+            if (ref === undefined) {
+                argTypes.push(InputType.Unknown);
+                continue;
+            }
+            const argVtx = this.dfg.getVertex(ref);
+            if (!argVtx) {
+                argTypes.push(InputType.Unknown);
+                continue;
+            }
+            const classified = this.classifyEntry(argVtx);
+            // collect all observed types from this argument
+            argTypes.push(...classified.type);
+            if (classified.cds) {
+                cdTypes.push(...classified.cds);
+            }
+        }
+        const cds = cdTypes.length > 0 ? (0, arrays_1.uniqueArray)(cdTypes) : undefined;
+        // all arguments only contain constant-like types -> derived constant
+        const allConstLike = argTypes.length > 0 && argTypes.every(t => t === InputType.Constant || t === InputType.DerivedConstant);
+        if (allConstLike) {
+            return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, type: [InputType.DerivedConstant], trace: InputTraceType.Pure, cds }));
+        }
+        const types = argTypes.length === 0 ? [InputType.DerivedConstant] : (0, arrays_1.uniqueArray)(argTypes);
+        return this.classifyCdsAndReturn(call, (0, objects_1.compactRecord)({ id: call.id, type: types, trace: InputTraceType.Known, cds }));
+    }
+    classifyVariable(vtx) {
+        const origins = df_helper_1.Dataflow.origin(this.dfg, vtx.id);
+        if (origins === undefined) {
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+        }
+        const types = [];
+        const cds = [];
+        let allPure = true;
+        for (const o of origins) {
+            if (o.type === 4 /* OriginType.ConstantOrigin */) {
+                types.push(InputType.Constant);
+                continue;
+            }
+            if (o.type === 0 /* OriginType.ReadVariableOrigin */ || o.type === 1 /* OriginType.WriteVariableOrigin */) {
+                const v = this.dfg.getVertex(o.id);
+                if (v) {
+                    // if this is a variable definition that is a parameter, classify as Parameter
+                    if (v.tag === vertex_1.VertexType.VariableDefinition && this.dfg.idMap?.get(v.id)?.info.role === "param-n" /* RoleInParent.ParameterName */) {
+                        types.push(InputType.Parameter);
+                        continue;
+                    }
+                    const c = this.classifyEntry(v);
+                    types.push(...c.type);
+                    if (c.cds) {
+                        cds.push(...c.cds);
+                    }
+                    if (c.trace !== InputTraceType.Pure) {
+                        allPure = false;
+                    }
+                }
+                else {
+                    types.push(InputType.Unknown);
+                }
+                continue;
+            }
+            if (o.type === 2 /* OriginType.FunctionCallOrigin */ || o.type === 3 /* OriginType.BuiltInFunctionOrigin */) {
+                const v = this.dfg.getVertex(o.id);
+                if (v) {
+                    const c = this.classifyEntry(v);
+                    types.push(...c.type);
+                    if (c.cds) {
+                        cds.push(...c.cds);
+                    }
+                    if (c.trace !== InputTraceType.Pure) {
+                        allPure = false;
+                    }
+                }
+                else {
+                    types.push(InputType.Unknown);
+                }
+                continue;
+            }
+            // unknown origin type
+            types.push(InputType.Unknown);
+        }
+        const t = types.length === 0 ? [InputType.Unknown] : (0, arrays_1.uniqueArray)(types);
+        const trace = allPure ? InputTraceType.Pure : InputTraceType.Alias;
+        return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: t, trace, cds: cds.length === 0 ? undefined : (0, arrays_1.uniqueArray)(cds) });
+    }
+    classifyVariableDefinition(vtx) {
+        // parameter definitions are classified as Parameter
+        if (this.dfg.idMap?.get(vtx.id)?.info.role === "param-n" /* RoleInParent.ParameterName */) {
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Parameter], trace: InputTraceType.Unknown });
+        }
+        const sources = vtx.source;
+        if (sources === undefined || sources.length === 0) {
+            // fallback to unknown if we cannot find the value
+            return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: [InputType.Unknown], trace: InputTraceType.Unknown });
+        }
+        const types = [];
+        const cds = [];
+        let allPure = true;
+        for (const tid of sources) {
+            const tv = this.dfg.getVertex(tid);
+            if (tv) {
+                const c = this.classifyEntry(tv);
+                types.push(...c.type);
+                if (c.cds) {
+                    cds.push(...c.cds);
+                }
+                if (c.trace !== InputTraceType.Pure) {
+                    allPure = false;
+                }
+            }
+            else {
+                types.push(InputType.Unknown);
+            }
+        }
+        const t = types.length === 0 ? [InputType.Unknown] : (0, arrays_1.uniqueArray)(types);
+        const trace = allPure ? InputTraceType.Pure : InputTraceType.Alias;
+        return this.classifyCdsAndReturn(vtx, { id: vtx.id, type: t, trace, cds: cds.length === 0 ? undefined : (0, arrays_1.uniqueArray)(cds) });
+    }
+    classifyCdsAndReturn(vtx, src) {
+        if (vtx.cds) {
+            const cds = (0, arrays_1.uniqueArray)(vtx.cds.flatMap(c => {
+                const cv = this.dfg.getVertex(c.id);
+                if (!cv) {
+                    return undefined;
+                }
+                const e = this.classifyEntry(cv);
+                return e.cds ? [...e.type, ...e.cds] : [...e.type];
+            }).filter(assert_1.isNotUndefined).concat(src.cds ?? []));
+            if (cds.length > 0) {
+                src.cds = cds;
+            }
+        }
+        if (src.cds?.length === 0) {
+            delete src.cds;
+        }
+        this.cache.set(vtx.id, src);
+        return src;
+    }
+}
+/**
+ * Lattice flattening until we have a taint engine :)
+ *
+ *```
+ *            [ Unknown ]
+ *     /     /     |     \       \
+ *[Param] [File] [Net] [Rand] [Scope]
+ *     \     \    |      /      /
+ *        [ DerivedConstant ]
+ *               |
+ *          [ Constant ]
+ *```
+ *
+ */
+var InputType;
+(function (InputType) {
+    InputType["Parameter"] = "param";
+    InputType["File"] = "file";
+    InputType["Network"] = "net";
+    InputType["Random"] = "rand";
+    InputType["Constant"] = "const";
+    /** Read from environment/call scope */
+    InputType["Scope"] = "scope";
+    /** Pure calculations from constants that lead to a constant */
+    InputType["DerivedConstant"] = "dconst";
+    InputType["Unknown"] = "unknown";
+})(InputType || (exports.InputType = InputType = {}));
+var InputTraceType;
+(function (InputTraceType) {
+    /** Derived only from aliasing */
+    InputTraceType["Alias"] = "alias";
+    /** Derived from pure function chains */
+    InputTraceType["Pure"] = "pure";
+    /** Derived from known but not necessarily all pure function chains */
+    InputTraceType["Known"] = "known";
+    /** Not fully known origin */
+    InputTraceType["Unknown"] = "unknown";
+})(InputTraceType || (exports.InputTraceType = InputTraceType = {}));
+function matchesList(fn, list) {
+    if (!list || list.length === 0) {
+        return false;
+    }
+    for (const id of list) {
+        if (fn.id === id || identifier_1.Identifier.matches(id, fn.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Takes the given id which is expected to either be:
+ * - a function call - in this case all arguments are considered to be inputs (additionally to all read edges from the function call in the dataflow graph)
+ * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you pased in.
+ *
+ * This method traces the dependencies in the dataflow graph using the specification of functions passed in
+ */
+function classifyInput(id, dfg, config) {
+    const vtx = dfg.getVertex(id);
+    if (!vtx) {
+        return [];
+    }
+    const c = new InputClassifier(dfg, config);
+    if (vtx.tag === vertex_1.VertexType.FunctionCall) {
+        const ret = [];
+        const args = vtx.args;
+        for (const arg of args) {
+            if (graph_1.FunctionArgument.isEmpty(arg)) {
+                continue;
+            }
+            const ref = graph_1.FunctionArgument.getReference(arg);
+            if (ref === undefined) {
+                continue;
+            }
+            const argVtx = dfg.getVertex(ref);
+            if (argVtx === undefined) {
+                continue;
+            }
+            ret.push(c.classifyEntry(argVtx));
+        }
+        return ret;
+    }
+    else {
+        return [
+            c.classifyEntry(vtx)
+        ];
+    }
+}
+//# sourceMappingURL=simple-input-classifier.js.map

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-executor.d.ts

@@ -1,13 +1,13 @@
 import type { InspectExceptionQuery, InspectExceptionQueryResult } from './inspect-exception-query-format';
 import type { BasicQueryData } from '../../base-query-format';
-import { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ReadonlyFlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 /**
  * Get the functions to consider in the call graph based on the given queries.
  */
 export declare function getFunctionsToConsiderInCallGraph(queries: readonly {
-    filter?: readonly SingleSlicingCriterion[];
+    filter?: readonly SlicingCriterion[];
 }[], analyzer: ReadonlyFlowrAnalysisProvider, onlyDefinitions?: boolean): Promise<{
     cg: import("../../../dataflow/graph/call-graph").CallGraph;
     fns: MapIterator<[NodeId, Required<import("../../../dataflow/graph/vertex").DataflowGraphVertexFunctionCall | import("../../../dataflow/graph/vertex").DataflowGraphVertexFunctionDefinition>]>;

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-executor.js

@@ -25,7 +25,7 @@ async function getFunctionsToConsiderInCallGraph(queries, analyzer, onlyDefiniti
     const filterFor = new Set();
     if (filters) {
         for (const f of filters) {
-            const i = parse_1.SingleSlicingCriterion.tryParse(f, ast.idMap);
+            const i = parse_1.SlicingCriterion.tryParse(f, ast.idMap);
             if (i !== undefined) {
                 filterFor.add(i);
             }

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-format.d.ts

@@ -6,7 +6,7 @@ import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id'
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
 import type { ExceptionPoint } from '../../../dataflow/fn/exceptions-of-function';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 /**
  * Either returns all function definitions alongside exception information,
  * or just those matching the filters.
@@ -14,7 +14,7 @@ import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 export interface InspectExceptionQuery extends BaseQueryFormat {
     readonly type: 'inspect-exception';
     /** If given, only function definitions that match one of the given slicing criteria are considered. */
-    readonly filter?: SingleSlicingCriterion[];
+    readonly filter?: SlicingCriterion[];
 }
 export interface InspectExceptionQueryResult extends BaseQueryResult {
     /**

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

@@ -26,7 +26,7 @@ async function executeHigherOrderQuery({ analyzer }, queries) {
     const filterFor = new Set();
     if (filters) {
         for (const f of filters) {
-            const i = parse_1.SingleSlicingCriterion.tryParse(f, ast.idMap);
+            const i = parse_1.SlicingCriterion.tryParse(f, ast.idMap);
             if (i !== undefined) {
                 filterFor.add(i);
             }

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.d.ts

@@ -3,7 +3,7 @@ import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeHigherOrderQuery } from './inspect-higher-order-query-executor';
 import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
 /**
@@ -12,7 +12,7 @@ import type { FlowrConfig } from '../../../config';
  */
 export interface InspectHigherOrderQuery extends BaseQueryFormat {
     readonly type: 'inspect-higher-order';
-    readonly filter?: SingleSlicingCriterion[];
+    readonly filter?: SlicingCriterion[];
 }
 export interface InspectHigherOrderQueryResult extends BaseQueryResult {
     readonly higherOrder: Record<NodeId, boolean>;

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-format.d.ts

@@ -3,7 +3,7 @@ import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeRecursionQuery } from './inspect-recursion-query-executor';
 import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
 /**
@@ -12,7 +12,7 @@ import type { FlowrConfig } from '../../../config';
  */
 export interface InspectRecursionQuery extends BaseQueryFormat {
     readonly type: 'inspect-recursion';
-    readonly filter?: SingleSlicingCriterion[];
+    readonly filter?: SlicingCriterion[];
 }
 export interface InspectRecursionQueryResult extends BaseQueryResult {
     readonly recursive: Record<NodeId, boolean>;

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

@@ -31,7 +31,7 @@ async function executeLocationMapQuery({ analyzer }, queries) {
     const start = Date.now();
     const criteriaOfInterest = new Set(queries
         .flatMap(q => q.ids ?? [])
-        .map(c => parse_1.SingleSlicingCriterion.tryParse(c, ast.idMap))
+        .map(c => parse_1.SlicingCriterion.tryParse(c, ast.idMap))
         .filter(assert_1.isNotUndefined));
     const locationMap = {
         files: {},

package/queries/catalog/location-map-query/location-map-query-format.d.ts

@@ -4,14 +4,14 @@ import { type OutputFormatter } from '../../../util/text/ansi';
 import Joi from 'joi';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { SourceRange } from '../../../util/range';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
 import type { ParsedQueryLine } from '../../query';
 export interface LocationMapQuery extends BaseQueryFormat {
     readonly type: 'location-map';
     /** Optional list of ids to filter the results by. If not provided, all ids will be included. */
-    readonly ids?: readonly SingleSlicingCriterion[];
+    readonly ids?: readonly SlicingCriterion[];
 }
 export type FileId = number & {
     readonly __fileId?: unique symbol;

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

@@ -1,10 +1,10 @@
 import type { BasicQueryData } from '../../base-query-format';
-import { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { OriginQuery, OriginQueryResult } from './origin-query-format';
 /**
  * Produce a fingerprint string for an origin query
  */
-export declare function fingerPrintOfQuery(query: OriginQuery): SingleSlicingCriterion;
+export declare function fingerPrintOfQuery(query: OriginQuery): SlicingCriterion;
 /**
  * Execute origin queries, catching duplicates with the same fingerprint
  */

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

@@ -22,7 +22,7 @@ async function executeResolveValueQuery({ analyzer }, queries) {
         if (results[key]) {
             log_1.log.warn(`Duplicate Key for origin-query: ${key}, skipping...`);
         }
-        const astId = parse_1.SingleSlicingCriterion.tryParse(key, (await analyzer.normalize()).idMap);
+        const astId = parse_1.SlicingCriterion.tryParse(key, (await analyzer.normalize()).idMap);
         if (astId === undefined) {
             log_1.log.warn(`Could not resolve id for ${key}, skipping...`);
             continue;

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

@@ -1,5 +1,5 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ParsedQueryLine } from '../../query';
 import Joi from 'joi';
 import { executeResolveValueQuery } from './origin-query-executor';
@@ -10,10 +10,10 @@ import type { FlowrConfig } from '../../../config';
 export interface OriginQuery extends BaseQueryFormat {
     readonly type: 'origin';
     /** The slicing criteria to use */
-    readonly criterion: SingleSlicingCriterion;
+    readonly criterion: SlicingCriterion;
 }
 export interface OriginQueryResult extends BaseQueryResult {
-    results: Record<SingleSlicingCriterion, Origin[] | undefined>;
+    results: Record<SlicingCriterion, Origin[] | undefined>;
 }
 declare function originQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfig): ParsedQueryLine<'origin'>;
 export declare const OriginQueryDefinition: {

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

@@ -1,9 +1,6 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { ProvenanceQuery, ProvenanceQueryResult } from './provenance-query-format';
 /**
- * Execute static slice queries, catching duplicates with the same fingerprint
- * @param analyzer - The basic query data containing the analyzer
- * @param queries - The static slice queries to execute
- * @returns The results of the static slice queries
+ * Execute a provenance query collection, {@link Dataflow.provenance}
  */
 export declare function executeProvenanceQuery({ analyzer }: BasicQueryData, queries: readonly ProvenanceQuery[]): Promise<ProvenanceQueryResult>;