@eagleoutice/flowr 2.9.13 → 2.10.1

package/linter/rules/problematic-eval.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROBLEMATIC_EVAL = void 0;
+const linter_format_1 = require("../linter-format");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const range_1 = require("../../util/range");
+const linter_tags_1 = require("../linter-tags");
+const simple_input_classifier_1 = require("../../queries/catalog/input-sources-query/simple-input-classifier");
+const query_1 = require("../../queries/query");
+const parse_1 = require("../../slicing/criterion/parse");
+/**
+ * Format a list of input sources either as a single-line string (inline) or a block.
+ * - inline: returns a semicolon-separated single-line summary
+ * - block: returns an array of lines (to be joined with newlines by the caller)
+ */
+function formatInputSources(inputs, inline = true) {
+    if (!inputs || inputs.length === 0) {
+        return inline ? '' : [];
+    }
+    if (inline) {
+        return inputs.map(s => `${s.id} (type: ${Array.isArray(s.type) ? '[' + s.type.join(',') + ']' : s.type}, trace: ${s.trace}${s.cds ? ', cds: [' + s.cds.join(',') + ']' : ''})`).join('; ');
+    }
+    return inputs.map(s => `- ${s.id}: type=${Array.isArray(s.type) ? '[' + s.type.join(',') + ']' : s.type}, trace=${s.trace}${s.cds ? ', cds=[' + s.cds.join(',') + ']' : ''}`);
+}
+exports.PROBLEMATIC_EVAL = {
+    /* create a search that finds calls that look like eval-like functions */
+    createSearch: config => flowr_search_builder_1.Q.fromQuery({
+        type: 'call-context',
+        callName: config.considerAsEval,
+        callNameExact: false
+    }),
+    processSearchResult: async (elements, _config, data) => {
+        const results = [];
+        for (const element of elements.getElements()) {
+            const nid = element.node.info.id;
+            // run an input-sources query for this eval-like call
+            const criterion = parse_1.SlicingCriterion.fromId(nid);
+            const q = { type: 'input-sources', criterion };
+            const all = await (0, query_1.executeQueries)({ analyzer: data.analyzer }, [q]);
+            const inputSourcesResult = all['input-sources'];
+            const sources = inputSourcesResult?.results?.[criterion] ?? [];
+            // if any input is not a constant or derived constant, flag it
+            const problematic = sources.some(s => Array.isArray(s.type)
+                ? s.type.some(t => t !== simple_input_classifier_1.InputType.Constant && t !== simple_input_classifier_1.InputType.DerivedConstant)
+                : (s.type !== simple_input_classifier_1.InputType.Constant && s.type !== simple_input_classifier_1.InputType.DerivedConstant));
+            if (problematic) {
+                results.push({
+                    involvedId: nid,
+                    certainty: sources.some(s => Array.isArray(s.type) ? s.type.includes(simple_input_classifier_1.InputType.Unknown) : s.type === simple_input_classifier_1.InputType.Unknown) ? linter_format_1.LintingResultCertainty.Uncertain : linter_format_1.LintingResultCertainty.Certain,
+                    loc: range_1.SourceLocation.fromNode(element.node) ?? range_1.SourceLocation.invalid(),
+                    sources
+                });
+            }
+        }
+        return {
+            results,
+            '.meta': {}
+        };
+    },
+    /* helper to format input sources for pretty printing */
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => {
+            const inputs = result.sources ?? [];
+            const srcStr = formatInputSources(inputs, true);
+            return `Use of eval-like function at ${range_1.SourceLocation.format(result.loc)}${srcStr ? `; inputs: ${srcStr}` : ''}`;
+        },
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => {
+            const inputs = result.sources ?? [];
+            const srcLines = formatInputSources(inputs, false);
+            return `Use of eval-like function at ${range_1.SourceLocation.format(result.loc)} is potentially problematic${srcLines.length ? '\nInputs:\n' + srcLines.join('\n') : ''}`;
+        }
+    },
+    info: {
+        name: 'Problematic eval',
+        description: 'Detects uses of eval-like functions whose inputs are not statically constant. Prints the computed input-sources for the eval and flags usages that depend on non-constant/trusted inputs.',
+        tags: [linter_tags_1.LintingRuleTag.Security, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Readability, linter_tags_1.LintingRuleTag.Performance],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        defaultConfig: {
+            considerAsEval: '^eval$'
+        }
+    }
+};
+//# sourceMappingURL=problematic-eval.js.map

package/linter/rules/seeded-randomness.js

@@ -19,7 +19,7 @@ const vertex_1 = require("../../dataflow/graph/vertex");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const r_value_1 = require("../../dataflow/eval/values/r-value");
 const info_1 = require("../../dataflow/info");
-const built_in_1 = require("../../dataflow/environments/built-in");
+const built_in_proc_name_1 = require("../../dataflow/environments/built-in-proc-name");
 exports.SEEDED_RANDOMNESS = {
     createSearch: (config) => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionCall)
         .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
@@ -140,7 +140,7 @@ exports.SEEDED_RANDOMNESS = {
     }
 };
 function getDefaultAssignments() {
-    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_1.BuiltInProcName.Assignment || b.processor === built_in_1.BuiltInProcName.AssignmentLike));
+    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_proc_name_1.BuiltInProcName.Assignment || b.processor === built_in_proc_name_1.BuiltInProcName.AssignmentLike));
 }
 function isConstantArgument(graph, call, argIndex, ctx) {
     const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);

package/linter/rules/stop-with-call-arg.d.ts

@@ -0,0 +1,35 @@
+import { type LintingResult, LintingRuleCertainty } from '../linter-format';
+import { SourceLocation } from '../../util/range';
+import type { MergeableRecord } from '../../util/objects';
+import { LintingRuleTag } from '../linter-tags';
+import type { Writable } from 'ts-essentials';
+export interface StopWithCallResult extends LintingResult {
+    readonly loc: SourceLocation;
+}
+export type StopWithCallConfig = MergeableRecord;
+export interface StopWithCallMetadata extends MergeableRecord {
+    consideredNodes: number;
+}
+export declare const STOP_WITH_CALL_ARG: {
+    readonly createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"get", ["filter"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: MergeableRecord, { dataflow, analyzer }: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
+    }) => {
+        results: Writable<StopWithCallResult>[];
+        '.meta': StopWithCallMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: StopWithCallResult) => string;
+        readonly full: (result: StopWithCallResult) => string;
+    };
+    readonly info: {
+        readonly name: "Stop without call.=False argument";
+        readonly tags: readonly [LintingRuleTag.Smell];
+        readonly certainty: LintingRuleCertainty.BestEffort;
+        readonly description: "Checks whether stop calls without call. argument set to FALSE are used.";
+        readonly defaultConfig: {};
+    };
+};

package/linter/rules/stop-with-call-arg.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_WITH_CALL_ARG = void 0;
+const linter_format_1 = require("../linter-format");
+const range_1 = require("../../util/range");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const linter_tags_1 = require("../linter-tags");
+const assert_1 = require("../../util/assert");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const alias_tracking_1 = require("../../dataflow/eval/resolve/alias-tracking");
+const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
+const linker_1 = require("../../dataflow/internal/linker");
+const general_1 = require("../../dataflow/eval/values/general");
+exports.STOP_WITH_CALL_ARG = {
+    createSearch: () => flowr_search_builder_1.Q.var('stop').filter(vertex_1.VertexType.FunctionCall),
+    processSearchResult: (elements, _config, { dataflow, analyzer }) => {
+        const meta = {
+            consideredNodes: 0
+        };
+        return {
+            results: elements.getElements()
+                .filter(element => {
+                //only built-in functions
+                const origins = (0, dfg_get_origin_1.getOriginInDfg)(dataflow.graph, element.node.info.id);
+                if ((0, assert_1.isNotUndefined)(origins)) {
+                    const builtIn = origins.every(e => e.type === 3 /* OriginType.BuiltInFunctionOrigin */);
+                    if (!builtIn) {
+                        return false;
+                    }
+                }
+                const fCall = dataflow.graph.getVertex(element.node.info.id);
+                //filter out function calls with argument "call." set to false
+                const stopParamMap = {
+                    '...': '...',
+                    'call.': 'call.',
+                    'domain': 'domain'
+                };
+                const mapping = (0, linker_1.pMatch)(fCall.args, stopParamMap);
+                const mappedToStop = mapping.get('call.') ?? [];
+                for (const argId of mappedToStop) {
+                    const res = (0, alias_tracking_1.resolveIdToValue)(argId, { graph: dataflow.graph, environment: fCall.environment, ctx: analyzer.inspectContext() });
+                    const values = (0, general_1.valueSetGuard)(res);
+                    if (values?.type === 'set' && values.elements.length !== 0) {
+                        if (values.elements[0].type === 'logical') {
+                            return values.elements[0].value;
+                        }
+                    }
+                }
+                return true;
+            })
+                .map(element => ({
+                certainty: linter_format_1.LintingResultCertainty.Uncertain,
+                involvedId: element.node.info.id,
+                loc: range_1.SourceLocation.fromNode(element.node)
+            }))
+                .filter(element => (0, assert_1.isNotUndefined)(element.loc)),
+            '.meta': meta
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Code at ${range_1.SourceLocation.format(result.loc)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Code at ${range_1.SourceLocation.format(result.loc)} does call stop without setting call. to FALSE`,
+    },
+    info: {
+        name: 'Stop without call.=False argument',
+        tags: [linter_tags_1.LintingRuleTag.Smell],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        description: 'Checks whether stop calls without call. argument set to FALSE are used.',
+        defaultConfig: {}
+    }
+};
+//# sourceMappingURL=stop-with-call-arg.js.map

package/linter/rules/useless-loop.d.ts

@@ -1,8 +1,8 @@
-import type { BuiltInProcName } from '../../dataflow/environments/built-in';
 import type { MergeableRecord } from '../../util/objects';
 import { SourceLocation } from '../../util/range';
 import { type LintingResult, LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
 import { LintingRuleTag } from '../linter-tags';
+import type { BuiltInProcName } from '../../dataflow/environments/built-in-proc-name';
 export interface UselessLoopResult extends LintingResult {
     name: string;
     loc: SourceLocation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.13",
+  "version": "2.10.1",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -165,8 +165,8 @@
     }
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.7.1",
-    "@commitlint/config-angular": "^19.7.1",
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-angular": "^20.5.0",
     "@eagleoutice/eslint-config-flowr": "^1.0.36",
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.2",
@@ -191,11 +191,11 @@
     "npm-run-all": "^4.1.5",
     "release-it": "^19.2.3",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.27.7",
-    "typedoc-plugin-missing-exports": "^3.1.0",
-    "typedoc-theme-hierarchy": "^5.0.4",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-missing-exports": "^4.1.2",
+    "typedoc-theme-hierarchy": "^6.0.0",
     "typedoc-umlclass": "^0.10.2",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "dependencies": {

package/project/cache/flowr-analyzer-cache.d.ts

@@ -9,7 +9,7 @@ import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplific
 import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
 import type { CfgKind } from '../cfg-kind';
 import type { FlowrAnalyzerContext } from '../context/flowr-analyzer-context';
-import type { CallGraph } from '../../dataflow/graph/call-graph';
+import { CallGraph } from '../../dataflow/graph/call-graph';
 interface FlowrAnalyzerCacheOptions<Parser extends KnownParser> {
     parser: Parser;
     context: FlowrAnalyzerContext;

package/project/cache/flowr-analyzer-cache.js

@@ -141,7 +141,7 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
      */
     async callGraph(force) {
         if (!this.callGraphCache || force) {
-            this.callGraphCache = (0, call_graph_1.computeCallGraph)((await this.dataflow(force)).graph);
+            this.callGraphCache = call_graph_1.CallGraph.compute((await this.dataflow(force)).graph);
         }
         return this.callGraphCache;
     }

package/project/flowr-analyzer-builder.d.ts

@@ -56,6 +56,9 @@ export declare class FlowrAnalyzerBuilder {
      * @param config - The new configuration.
      */
     setConfig(config: FlowrConfig): this;
+    /**
+     * Set a specific value in the configuration used by the resulting analyzer.
+     */
     configure<K extends AutocompletablePaths<FlowrConfig>>(key: K, value: PathValue<FlowrConfig, K>): this;
     /**
      * Set the parser instance used by the analyzer.

package/project/flowr-analyzer.d.ts

@@ -15,8 +15,8 @@ import type { RAnalysisRequest } from './context/flowr-analyzer-files-context';
 import type { RParseRequest, RParseRequestFromFile } from '../r-bridge/retriever';
 import { fileProtocol } from '../r-bridge/retriever';
 import type { FlowrFileProvider } from './context/flowr-file';
-import type { CallGraph } from '../dataflow/graph/call-graph';
 import type { Tree } from 'web-tree-sitter';
+import type { CallGraph } from '../dataflow/graph/call-graph';
 /**
  * Extends the {@link ReadonlyFlowrAnalysisProvider} with methods that allow modifying the analyzer state.
  */

package/queries/catalog/call-context-query/identify-link-to-nested-call-relation.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifyLinkToNestedRelation = identifyLinkToNestedRelation;
-const call_graph_1 = require("../../../dataflow/graph/call-graph");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const call_graph_1 = require("../../../dataflow/graph/call-graph");
 /**
  * **Please refer to {@link identifyLinkToRelation}.**
  *
@@ -19,7 +19,7 @@ async function identifyLinkToNestedRelation(from, analyzer, { callName, ignoreIf
     const test = callName instanceof RegExp ? (t) => callName.test(t) : callName;
     const found = [];
     const cg = await analyzer.callGraph();
-    const subCg = (0, call_graph_1.getSubCallGraph)(cg, new Set([from]));
+    const subCg = call_graph_1.CallGraph.computeSubCallGraph(cg, new Set([from]));
     for (const [, t] of subCg.vertices(true)) {
         if (!(0, vertex_1.isFunctionCallVertex)(t)) {
             continue;

package/queries/catalog/call-graph-query/call-graph-query-format.d.ts

@@ -2,7 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import { executeCallGraphQuery } from './call-graph-query-executor';
 import Joi from 'joi';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { CallGraph } from '../../../dataflow/graph/call-graph';
+import { CallGraph } from '../../../dataflow/graph/call-graph';
 /**
  * Computes the Call Graph of the analyzed project.
  */

package/queries/catalog/call-graph-query/call-graph-query-format.js

@@ -7,14 +7,14 @@ exports.CallGraphQueryDefinition = void 0;
 const call_graph_query_executor_1 = require("./call-graph-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const call_graph_1 = require("../../../dataflow/graph/call-graph");
 exports.CallGraphQueryDefinition = {
     executor: call_graph_query_executor_1.executeCallGraphQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('call-graph', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Call Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        result.push(`   ╰ [Call Graph](${call_graph_1.CallGraph.visualize.mermaid.url(out.graph)})`);
         return true;
     },
     schema: joi_1.default.object({

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

@@ -7,8 +7,8 @@ exports.ClusterQueryDefinition = void 0;
 const ansi_1 = require("../../../util/text/ansi");
 const joi_1 = __importDefault(require("joi"));
 const cluster_query_executor_1 = require("./cluster-query-executor");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const query_print_1 = require("../../query-print");
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.ClusterQueryDefinition = {
     executor: cluster_query_executor_1.executeDataflowClusterQuery,
     asciiSummarizer: async (formatter, analyzer, queryResults, result) => {
@@ -19,7 +19,7 @@ exports.ClusterQueryDefinition = {
             const unknownSideEffects = cluster.hasUnknownSideEffects ? '(has unknown side effect)' : '';
             let suffix = '';
             if (formatter === ansi_1.markdownFormatter) {
-                suffix = `([marked](${(0, dfg_1.graphToMermaidUrl)((await analyzer.dataflow()).graph, false, new Set(cluster.members))}))`;
+                suffix = `([marked](${df_helper_1.Dataflow.visualize.mermaid.url((await analyzer.dataflow()).graph, false, new Set(cluster.members))}))`;
             }
             result.push(`      ╰ ${unknownSideEffects} {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, cluster.members)}} ${suffix}`);
         }

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-format.js

@@ -7,14 +7,14 @@ exports.DataflowLensQueryDefinition = void 0;
 const dataflow_lens_query_executor_1 = require("./dataflow-lens-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.DataflowLensQueryDefinition = {
     executor: dataflow_lens_query_executor_1.executeDataflowLensQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dataflow-lens', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Simplified Graph](${(0, dfg_1.graphToMermaidUrl)(out.simplifiedGraph, false, undefined, true)})`);
+        result.push(`   ╰ [Simplified Graph](${df_helper_1.Dataflow.visualize.mermaid.url(out.simplifiedGraph, false, undefined, true)})`);
         return true;
     },
     schema: joi_1.default.object({

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

@@ -7,14 +7,14 @@ exports.DataflowQueryDefinition = void 0;
 const dataflow_query_executor_1 = require("./dataflow-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.DataflowQueryDefinition = {
     executor: dataflow_query_executor_1.executeDataflowQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dataflow', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Dataflow Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        result.push(`   ╰ [Dataflow Graph](${df_helper_1.Dataflow.visualize.mermaid.url(out.graph)})`);
         return true;
     },
     schema: joi_1.default.object({

package/queries/catalog/df-shape-query/df-shape-query-executor.js

@@ -39,14 +39,13 @@ async function executeDfShapeQuery({ analyzer }, queries) {
             continue;
         }
         try {
-            const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
+            const nodeId = parse_1.SlicingCriterion.parse(query.criterion, ast.idMap);
             const node = ast.idMap.get(nodeId);
             const value = inference.getAbstractValue(node?.info.id);
             result.set(query.criterion, value);
         }
         catch (e) {
             console.error(e instanceof Error ? e.message : e);
-            continue;
         }
     }
     return {

package/queries/catalog/df-shape-query/df-shape-query-format.d.ts

@@ -3,17 +3,17 @@ import type { DataFrameDomain } from '../../../abstract-interpretation/data-fram
 import type { StateAbstractDomain } from '../../../abstract-interpretation/domains/state-abstract-domain';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { ParsedQueryLine } from '../../query';
 import { executeDfShapeQuery } from './df-shape-query-executor';
 /** Infer the shape of data frames using abstract interpretation. */
 export interface DfShapeQuery extends BaseQueryFormat {
     readonly type: 'df-shape';
-    readonly criterion?: SingleSlicingCriterion;
+    readonly criterion?: SlicingCriterion;
 }
 export interface DfShapeQueryResult extends BaseQueryResult {
-    domains: StateAbstractDomain<DataFrameDomain> | Map<SingleSlicingCriterion, DataFrameDomain | undefined>;
+    domains: StateAbstractDomain<DataFrameDomain> | Map<SlicingCriterion, DataFrameDomain | undefined>;
 }
 declare function dfShapeQueryLineParser(_output: ReplOutput, line: readonly string[], _config: FlowrConfig): ParsedQueryLine<'df-shape'>;
 export declare const DfShapeQueryDefinition: {

package/queries/catalog/does-call-query/does-call-query-executor.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDoesCallQuery = executeDoesCallQuery;
 const log_1 = require("../../../util/log");
 const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
-const parse_1 = require("../../../slicing/criterion/parse");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const parse_1 = require("../../../slicing/criterion/parse");
 /**
  * Execute does call queries on the given analyzer.
  */
@@ -19,7 +19,7 @@ async function executeDoesCallQuery({ analyzer }, queries) {
             log_1.log.warn(`Duplicate query id '${id}' in does-call queries, SKIP.`);
             continue;
         }
-        const nodeId = (0, parse_1.tryResolveSliceCriterionToId)(query.call, idMap);
+        const nodeId = parse_1.SlicingCriterion.tryParse(query.call, idMap);
         if (!nodeId) {
             results[id] = false;
             continue;

package/queries/catalog/does-call-query/does-call-query-format.d.ts

@@ -3,7 +3,7 @@ import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeDoesCallQuery } from './does-call-query-executor';
 import { type 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';
 interface CallsIdConstraint {
@@ -30,7 +30,7 @@ export type CallsConstraint = CallsIdConstraint | CallsWithNameConstraint | Call
 export interface DoesCallQuery extends BaseQueryFormat {
     readonly type: 'does-call';
     readonly queryId?: string;
-    readonly call: SingleSlicingCriterion;
+    readonly call: SlicingCriterion;
     readonly calls: CallsConstraint;
 }
 export interface FindAllCallsResult {

package/queries/catalog/happens-before-query/happens-before-query-executor.js

@@ -22,8 +22,8 @@ async function executeHappensBefore({ analyzer }, queries) {
             log_1.log.warn('Duplicate happens-before query', query, 'ignoring');
         }
         try {
-            const resolvedA = (0, parse_1.slicingCriterionToId)(a, ast.idMap);
-            const resolvedB = (0, parse_1.slicingCriterionToId)(b, ast.idMap);
+            const resolvedA = parse_1.SlicingCriterion.parse(a, ast.idMap);
+            const resolvedB = parse_1.SlicingCriterion.parse(b, ast.idMap);
             results[fingerprint] = (0, happens_before_1.happensBefore)(cfg.graph, resolvedA, resolvedB);
         }
         catch (e) {

package/queries/catalog/happens-before-query/happens-before-query-format.d.ts

@@ -1,12 +1,12 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import { executeHappensBefore } from './happens-before-query-executor';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { Ternary } from '../../../util/logic';
 export interface HappensBeforeQuery extends BaseQueryFormat {
     readonly type: 'happens-before';
-    readonly a: SingleSlicingCriterion;
-    readonly b: SingleSlicingCriterion;
+    readonly a: SlicingCriterion;
+    readonly b: SlicingCriterion;
 }
 export interface HappensBeforeQueryResult extends BaseQueryResult {
     readonly results: Record<string, Ternary>;

package/queries/catalog/input-sources-query/input-sources-query-executor.d.ts

@@ -0,0 +1,6 @@
+import type { BasicQueryData } from '../../base-query-format';
+import type { InputSourcesQuery, InputSourcesQueryResult } from './input-sources-query-format';
+/**
+ * Execute an input sources query
+ */
+export declare function executeInputSourcesQuery({ analyzer }: BasicQueryData, queries: readonly InputSourcesQuery[]): Promise<InputSourcesQueryResult>;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeInputSourcesQuery = executeInputSourcesQuery;
+const log_1 = require("../../../util/log");
+const parse_1 = require("../../../slicing/criterion/parse");
+const r_function_definition_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
+const simple_input_classifier_1 = require("./simple-input-classifier");
+const network_functions_1 = require("../../../linter/rules/network-functions");
+const seeded_randomness_1 = require("../../../linter/rules/seeded-randomness");
+const read_functions_1 = require("../dependencies-query/function-info/read-functions");
+/**
+ * Execute an input sources query
+ */
+async function executeInputSourcesQuery({ analyzer }, queries) {
+    const start = Date.now();
+    const results = {};
+    const nast = await analyzer.normalize();
+    const df = await analyzer.dataflow();
+    for (const query of queries) {
+        const key = query.criterion;
+        if (results[key]) {
+            log_1.log.warn(`Duplicate key for input-sources query: ${key}, skipping...`);
+        }
+        const criterionId = parse_1.SlicingCriterion.tryParse(key, nast.idMap) ?? key;
+        const provenanceNode = nast.idMap.get(criterionId);
+        const fdef = r_function_definition_1.RFunctionDefinition.rootFunctionDefinition(provenanceNode, nast.idMap);
+        const provenance = df_helper_1.Dataflow.provenanceGraph(criterionId, df.graph, fdef ? model_1.RNode.collectAllIds(fdef) : undefined);
+        results[key] = (0, simple_input_classifier_1.classifyInput)(criterionId, provenance, {
+            networkFns: query.config?.networkFns ?? network_functions_1.NETWORK_FUNCTIONS.info.defaultConfig.fns,
+            randomFns: query.config?.randomFns ?? seeded_randomness_1.SEEDED_RANDOMNESS.info.defaultConfig.randomnessConsumers,
+            pureFns: query.config?.pureFns ?? ['paste', 'paste0', 'parse', '+', '-', '*',
+                '/', '^', '%%', '%/%', '&', '|', '!', '&&', '||',
+                '<', '>', '<=', '>=', '==', '!=', ':',
+                'abs', 'sign', 'sqrt', 'exp', 'log', 'log10', 'log2',
+                'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+                'length', 'nchar', 'dim', 'nrow', 'ncol',
+                'c', 'list', 'data.frame',
+                'ifelse', 'switch', 'factor', 'as.factor',
+                'round', 'floor', 'ceiling', 'trunc',
+                'substr', 'substring', 'strsplit',
+                'min', 'max', 'range', 'sum', 'prod', 'mean', 'median', 'var', 'sd',
+                'head', 'tail', 'seq', 'rep',
+                'apply', 'lapply', 'sapply', 'vapply', 'tapply',
+                'matrix', 'array', 'substitute', 'quote', 'bquote', 'enquote', 'enexpr', 'enexprs', 'enquo', 'enquos',
+                'expression', 'call', 'as.call', 'as.expression',
+                'rownames', 'colnames',
+                'list.files', 'tolower', 'toupper', 'printf',
+                '<-', '->', '=', '<<-', '->>', 'assign', 'get',
+                '[', '[[', '$', 'length<-', 'dim<-', 'names<-', 'colnames<-', 'rownames<-',
+                'as.character', 'as.numeric', 'as.logical', 'as.list', 'as.data.frame', 'as.matrix', 'as.array',
+                'identity', 'invisible', 'return', 'force', 'missing',
+                'print', 'cat', 'message', 'warning', 'stop'
+            ],
+            readFileFns: query.config?.readFileFns ?? read_functions_1.ReadFunctions.map(f => f.name)
+        });
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+//# sourceMappingURL=input-sources-query-executor.js.map

package/queries/catalog/input-sources-query/input-sources-query-format.d.ts

@@ -0,0 +1,36 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
+import type { ParsedQueryLine } from '../../query';
+import Joi from 'joi';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { InputClassifierConfig, InputSources } from './simple-input-classifier';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfig } from '../../../config';
+import { executeInputSourcesQuery } from './input-sources-query-executor';
+export type InputSourcesQueryConfig = InputClassifierConfig;
+/**
+ * Calculates provenance for all inputs and their transformations
+ * based on the `provenance` of a given function.
+ */
+export interface InputSourcesQuery extends BaseQueryFormat {
+    readonly type: 'input-sources';
+    /**
+     * This takes a criterion (or a numerical id works too)
+     * {@link SlicingCriterion.fromId}
+     */
+    readonly criterion: SlicingCriterion;
+    readonly config?: InputSourcesQueryConfig;
+}
+export interface InputSourcesQueryResult extends BaseQueryResult {
+    /** For each query key, a list of classified input sources (each with id and all traces) */
+    results: Record<string, InputSources>;
+}
+declare function inputSourcesQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfig): ParsedQueryLine<'input-sources'>;
+export declare const InputSourcesDefinition: {
+    readonly executor: typeof executeInputSourcesQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly fromLine: typeof inputSourcesQueryLineParser;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};
+export {};