@eagleoutice/flowr 2.2.14 → 2.2.16

package/linter/rules/seeded-randomness.d.ts

@@ -0,0 +1,65 @@
+import type { LintingResult } from '../linter-format';
+import { LintingCertainty } from '../linter-format';
+import type { SourceRange } from '../../util/range';
+import type { MergeableRecord } from '../../util/objects';
+import type { Identifier } from '../../dataflow/environments/identifier';
+import { LintingRuleTag } from '../linter-tags';
+export interface SeededRandomnessResult extends LintingResult {
+    function: string;
+    range: SourceRange;
+}
+export interface SeededRandomnessConfig extends MergeableRecord {
+    /**
+     * A set of functions and variables whose invocation or assignment causes a random seeded to be set.
+     * Each entry has a `type`, which is either `function` or `assignment`, and a `name`, which is the name of the function or variable.
+     * The default value for this is the function `set.seed` and the variable `.Random.seed`.
+     */
+    randomnessProducers: {
+        type: 'function' | 'assignment';
+        name: string;
+    }[];
+    /**
+     * A set of randomness consumer function names that require a seed to be set prior to invocation.
+     */
+    randomnessConsumers: string[];
+}
+export interface SeededRandomnessMeta extends MergeableRecord {
+    consumerCalls: number;
+    callsWithFunctionProducers: number;
+    callsWithAssignmentProducers: number;
+    callsWithNonConstantProducers: number;
+}
+export declare const SEEDED_RANDOMNESS: {
+    readonly createSearch: (config: SeededRandomnessConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter", "with"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/search-executor/search-enrichers").EnrichedFlowrSearchElement<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: SeededRandomnessConfig, { dataflow }: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: {
+            certainty: LintingCertainty.Definitely;
+            function: Identifier;
+            range: SourceRange;
+        }[];
+        '.meta': SeededRandomnessMeta;
+    };
+    readonly info: {
+        readonly defaultConfig: {
+            readonly randomnessProducers: readonly [{
+                readonly type: "function";
+                readonly name: "set.seed";
+            }, {
+                readonly type: "assignment";
+                readonly name: ".Random.seed";
+            }];
+            readonly randomnessConsumers: readonly ["jitter", "sample", "sample.int", "arima.sim", "kmeans", "princomp", "rcauchy", "rchisq", "rexp", "rgamma", "rgeom", "rlnorm", "rlogis", "rmultinom", "rnbinom", "rnorm", "rpois", "runif", "pointLabel", "some", "rbernoulli", "rdunif", "generateSeedVectors"];
+        };
+        readonly tags: readonly [LintingRuleTag.Robustness, LintingRuleTag.Reproducibility];
+        readonly name: "Seeded Randomness";
+        readonly description: "Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.";
+    };
+    readonly prettyPrint: {
+        readonly query: (result: SeededRandomnessResult, _meta: SeededRandomnessMeta) => string;
+        readonly full: (result: SeededRandomnessResult, _meta: SeededRandomnessMeta) => string;
+    };
+};

package/linter/rules/seeded-randomness.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEEDED_RANDOMNESS = void 0;
+const linter_format_1 = require("../linter-format");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const dfg_1 = require("../../util/mermaid/dfg");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
+const flowr_search_filters_1 = require("../../search/flowr-search-filters");
+const default_builtin_config_1 = require("../../dataflow/environments/default-builtin-config");
+const graph_1 = require("../../dataflow/graph/graph");
+const cascade_action_1 = require("../../queries/catalog/call-context-query/cascade-action");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const linter_tags_1 = require("../linter-tags");
+const alias_tracking_1 = require("../../dataflow/eval/resolve/alias-tracking");
+const general_1 = require("../../dataflow/eval/values/general");
+const config_1 = require("../../config");
+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");
+exports.SEEDED_RANDOMNESS = {
+    createSearch: (config) => flowr_search_builder_1.Q.all()
+        .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
+        .filter({
+        name: flowr_search_filters_1.FlowrFilter.MatchesEnrichment,
+        args: {
+            enrichment: search_enrichers_1.Enrichment.CallTargets,
+            test: (0, flowr_search_filters_1.testFunctionsIgnoringPackage)(config.randomnessConsumers)
+        }
+    })
+        .with(search_enrichers_1.Enrichment.LastCall, [
+        ...config.randomnessProducers.filter(p => p.type === 'function').map(p => ({ callName: p.name })),
+        ...getDefaultAssignments().flatMap(b => b.names).map(a => ({ callName: a, cascadeIf: () => cascade_action_1.CascadeAction.Continue }))
+    ]),
+    processSearchResult: (elements, config, { dataflow }) => {
+        const assignmentProducers = new Set(config.randomnessProducers.filter(p => p.type == 'assignment').map(p => p.name));
+        const assignmentArgIndexes = new Map(getDefaultAssignments().flatMap(a => a.names.map(n => ([n, a.config?.swapSourceAndTarget ? 1 : 0]))));
+        const metadata = {
+            consumerCalls: 0,
+            callsWithFunctionProducers: 0,
+            callsWithAssignmentProducers: 0,
+            callsWithNonConstantProducers: 0
+        };
+        return {
+            results: elements.getElements()
+                // map and filter consumers
+                .flatMap(element => (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CallTargets).targets.map(target => {
+                metadata.consumerCalls++;
+                return {
+                    range: element.node.info.fullRange,
+                    target: target,
+                    searchElement: element
+                };
+            }))
+                // filter by calls that aren't preceded by a randomness producer
+                .filter(element => {
+                const producers = (0, search_enrichers_1.enrichmentContent)(element.searchElement, search_enrichers_1.Enrichment.LastCall).linkedIds
+                    .map(e => dataflow.graph.getVertex(e.node.info.id));
+                const { assignment, func } = Object.groupBy(producers, f => assignmentArgIndexes.has(f.name) ? 'assignment' : 'func');
+                let nonConstant = false;
+                // function calls are already taken care of through the LastCall enrichment itself
+                for (const f of func ?? []) {
+                    if (isConstantArgument(dataflow.graph, f, 0)) {
+                        metadata.callsWithFunctionProducers++;
+                        return false;
+                    }
+                    else {
+                        nonConstant = true;
+                    }
+                }
+                // assignments have to be queried for their destination
+                for (const a of assignment ?? []) {
+                    const argIdx = assignmentArgIndexes.get(a.name);
+                    const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
+                    if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
+                        if (isConstantArgument(dataflow.graph, a, 1 - argIdx)) {
+                            metadata.callsWithAssignmentProducers++;
+                            return false;
+                        }
+                        else {
+                            nonConstant = true;
+                        }
+                    }
+                }
+                if (nonConstant) {
+                    metadata.callsWithNonConstantProducers++;
+                }
+                return true;
+            })
+                .map(element => ({
+                certainty: linter_format_1.LintingCertainty.Definitely,
+                function: element.target,
+                range: element.range
+            })),
+            '.meta': metadata
+        };
+    },
+    info: {
+        defaultConfig: {
+            randomnessProducers: [{ type: 'function', name: 'set.seed' }, { type: 'assignment', name: '.Random.seed' }],
+            randomnessConsumers: ['jitter', 'sample', 'sample.int', 'arima.sim', 'kmeans', 'princomp', 'rcauchy', 'rchisq', 'rexp', 'rgamma', 'rgeom', 'rlnorm', 'rlogis', 'rmultinom', 'rnbinom', 'rnorm', 'rpois', 'runif', 'pointLabel', 'some', 'rbernoulli', 'rdunif', 'generateSeedVectors'],
+        },
+        tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility],
+        name: 'Seeded Randomness',
+        description: 'Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.'
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: (result, _meta) => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: (result, _meta) => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)} is called without a preceding random seed function like \`set.seed\``
+    }
+};
+function getDefaultAssignments() {
+    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && b.processor == 'builtin:assignment');
+}
+function isConstantArgument(graph, call, argIndex) {
+    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+    const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias }));
+    return values?.elements.every(v => v.type === 'number' ||
+        v.type === 'logical' ||
+        v.type === 'string' ||
+        v.type === 'interval' && v.startInclusive && v.endInclusive && v.start.type === 'number' && v.end.type === 'number' && (0, r_value_1.asValue)(v.start.value).num === (0, r_value_1.asValue)(v.end.value).num)
+        ?? false;
+}
+//# sourceMappingURL=seeded-randomness.js.map

package/linter/rules/unused-definition.d.ts

@@ -0,0 +1,41 @@
+import type { LintingResult } from '../linter-format';
+import type { MergeableRecord } from '../../util/objects';
+import type { SourceRange } from '../../util/range';
+import { LintingRuleTag } from '../linter-tags';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export interface UnusedDefinitionResult extends LintingResult {
+    variableName?: string;
+    range: SourceRange;
+}
+export interface UnusedDefinitionConfig extends MergeableRecord {
+    /**
+     * Whether to include (potentially anonymous) function definitions in the search (e.g., should we report uncalled anonymous functions?).
+     */
+    includeFunctionDefinitions: boolean;
+}
+export interface UnusedDefinitionMetadata extends MergeableRecord {
+    totalConsidered: number;
+}
+export declare const UNUSED_DEFINITION: {
+    readonly createSearch: (config: UnusedDefinitionConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], ParentInformation, import("../../search/flowr-search").FlowrSearchElements<ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>>;
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<ParentInformation, import("../../search/flowr-search").FlowrSearchElement<ParentInformation>[]>, config: UnusedDefinitionConfig, data: {
+        normalize: NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: UnusedDefinitionResult[];
+        ".meta": UnusedDefinitionMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: UnusedDefinitionResult) => string;
+        readonly full: (result: UnusedDefinitionResult) => string;
+    };
+    readonly info: {
+        readonly name: "Unused Definitions";
+        readonly description: "Checks for unused definitions.";
+        readonly tags: readonly [LintingRuleTag.Readability, LintingRuleTag.Smell, LintingRuleTag.QuickFix];
+        readonly defaultConfig: {
+            readonly includeFunctionDefinitions: true;
+        };
+    };
+};

package/linter/rules/unused-definition.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNUSED_DEFINITION = 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 dfg_1 = require("../../util/mermaid/dfg");
+const linter_tags_1 = require("../linter-tags");
+const assert_1 = require("../../util/assert");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const edge_1 = require("../../dataflow/graph/edge");
+const flowr_search_filters_1 = require("../../search/flowr-search-filters");
+const InterestingEdgesVariable = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls | edge_1.EdgeType.DefinesOnCall;
+const InterestingEdgesFunction = edge_1.EdgeType.Reads | edge_1.EdgeType.Calls; // include read as this could print the function definition
+const InterestingEdgesTargets = edge_1.EdgeType.SideEffectOnCall;
+function getDefinitionArguments(def, dfg) {
+    return [...dfg.outgoingEdges(def) ?? []].filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.DefinedBy))
+        .map(([target]) => target);
+}
+function buildQuickFix(variable, dfg, ast) {
+    // first we check whether any of the 'Defined by' targets have any obligations - if so, we can not remove the definition
+    // otherwise we can automatically remove the full definition!
+    if (variable.info.role === "accessed" /* RoleInParent.Accessed */ || variable.info.role === "for-variable" /* RoleInParent.ForVariable */) {
+        // this is an access or a for variable, we can not remove it currently
+        return undefined;
+    }
+    const definedBys = getDefinitionArguments(variable.info.id, dfg);
+    const hasImportantArgs = definedBys.some(d => dfg.unknownSideEffects.has(d))
+        || definedBys.flatMap(e => [...dfg.outgoingEdges(e) ?? []])
+            .some(([target, { types }]) => {
+            return (0, edge_1.edgeIncludesType)(types, InterestingEdgesTargets) || dfg.unknownSideEffects.has(target);
+        });
+    if (hasImportantArgs) {
+        return undefined; // we can not remove this definition, it has important arguments
+    }
+    const totalRangeToRemove = (0, range_1.mergeRanges)(...definedBys.map(d => {
+        const vertex = ast.idMap.get(d);
+        return vertex?.info.fullRange ?? vertex?.location;
+    }), variable.info.fullRange ?? variable.location);
+    return [{
+            type: 'remove',
+            range: totalRangeToRemove,
+            description: `Remove unused definition of \`${variable.lexeme}\``
+        }];
+}
+/**
+ * consider `x <- function() ...` if we say `x` is unused and propose to remove everything, there should be no separate quick fix for the function definition
+ */
+function onlyKeepSupersetOfUnused(elements) {
+    const ranges = elements.flatMap(e => e.quickFix?.map(q => q.range) ?? [e.range]);
+    if (ranges.length <= 1) {
+        return elements; // nothing to filter, only one element
+    }
+    return elements.filter(e => {
+        const otherRange = (0, range_1.mergeRanges)(...(e.quickFix?.map(q => q.range) ?? [e.range]));
+        return !ranges.some(r => (0, range_1.rangeCompare)(r, otherRange) !== 0 && (0, range_1.rangeIsSubsetOf)(otherRange, r)); // there is no smaller remove
+    });
+}
+exports.UNUSED_DEFINITION = {
+    /* this can be done better once we have types */
+    createSearch: config => flowr_search_builder_1.Q.all().filter(config.includeFunctionDefinitions ? flowr_search_filters_1.FlowrFilterCombinator.is(vertex_1.VertexType.VariableDefinition).or(vertex_1.VertexType.FunctionDefinition) : vertex_1.VertexType.VariableDefinition),
+    processSearchResult: (elements, config, data) => {
+        const metadata = {
+            totalConsidered: 0
+        };
+        return {
+            results: onlyKeepSupersetOfUnused(elements.getElements().flatMap(element => {
+                metadata.totalConsidered++;
+                const dfgVertex = data.dataflow.graph.getVertex(element.node.info.id);
+                if (!dfgVertex || (!(0, vertex_1.isVariableDefinitionVertex)(dfgVertex)
+                    && (0, vertex_1.isFunctionDefinitionVertex)(dfgVertex) && !config.includeFunctionDefinitions)) {
+                    return undefined;
+                }
+                const ingoingEdges = data.dataflow.graph.ingoingEdges(dfgVertex.id);
+                const interestedIn = (0, vertex_1.isVariableDefinitionVertex)(dfgVertex) ? InterestingEdgesVariable : InterestingEdgesFunction;
+                const ingoingInteresting = ingoingEdges?.values().some(e => (0, edge_1.edgeIncludesType)(e.types, interestedIn));
+                if (ingoingInteresting) {
+                    return undefined;
+                }
+                // found an unused definition
+                const variableName = element.node.lexeme;
+                return [{
+                        certainty: linter_format_1.LintingCertainty.Maybe,
+                        variableName,
+                        range: element.node.info.fullRange ?? element.node.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+                        quickFix: buildQuickFix(element.node, data.dataflow.graph, data.normalize)
+                    }];
+            }).filter(assert_1.isNotUndefined)),
+            '.meta': metadata
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Definition of \`${result.variableName}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Definition of \`${result.variableName}\` at ${(0, dfg_1.formatRange)(result.range)} is unused`
+    },
+    info: {
+        name: 'Unused Definitions',
+        description: 'Checks for unused definitions.',
+        tags: [linter_tags_1.LintingRuleTag.Readability, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.QuickFix],
+        defaultConfig: {
+            includeFunctionDefinitions: true
+        }
+    }
+};
+//# sourceMappingURL=unused-definition.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.2.14",
+  "version": "2.2.16",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -39,6 +39,7 @@
     "wiki:cfg": "ts-node src/documentation/print-cfg-wiki.ts",
     "wiki:linter": "ts-node src/documentation/print-linter-wiki.ts",
     "gen:readme": "ts-node src/documentation/print-readme.ts",
+    "gen:linter-issue": "ts-node src/documentation/print-linter-issue.ts",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
     "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",
@@ -184,6 +185,7 @@
     "@types/n-readlines": "^1.0.6",
     "@types/n3": "^1.21.1",
     "@types/object-hash": "^3.0.6",
+    "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.5.8",
     "@types/tmp": "^0.2.6",
     "@types/ws": "^8.5.14",
@@ -215,6 +217,7 @@
     "object-hash": "^3.0.0",
     "object-sizeof": "^2.6.5",
     "rotating-file-stream": "^3.2.6",
+    "seedrandom": "^3.0.5",
     "semver": "^7.7.1",
     "tar": "^7.4.3",
     "tmp": "^0.2.3",

package/queries/base-query-format.d.ts

@@ -1,5 +1,6 @@
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
+import type { FlowrConfigOptions } from '../config';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -14,4 +15,5 @@ export interface BaseQueryResult {
 export interface BasicQueryData {
     readonly ast: NormalizedAst;
     readonly dataflow: DataflowInformation;
+    readonly config: FlowrConfigOptions;
 }

package/queries/catalog/call-context-query/call-context-query-executor.d.ts

@@ -9,4 +9,4 @@ import type { BasicQueryData } from '../../base-query-format';
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-export declare function executeCallContextQueries({ dataflow: { graph }, ast }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;
+export declare function executeCallContextQueries({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly CallContextQuery[]): CallContextQueryResult;

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

@@ -171,7 +171,7 @@ function isParameterDefaultValue(nodeId, ast) {
  *    This happens during the main resolution!
  * 4. Attach `linkTo` calls to the respective calls.
  */
-function executeCallContextQueries({ dataflow: { graph }, ast }, queries) {
+function executeCallContextQueries({ dataflow: { graph }, ast, config }, queries) {
     /* omit performance page load */
     const now = Date.now();
     /* the node id and call targets if present */
@@ -180,7 +180,7 @@ function executeCallContextQueries({ dataflow: { graph }, ast }, queries) {
     const { promotedQueries, requiresCfg } = promoteQueryCallNames(queries);
     let cfg = undefined;
     if (requiresCfg) {
-        cfg = (0, extract_cfg_1.extractCfg)(ast, graph, []);
+        cfg = (0, extract_cfg_1.extractCfg)(ast, config, graph, []);
     }
     const queriesWhichWantAliases = promotedQueries.filter(q => q.includeAliases);
     for (const [nodeId, info] of graph.vertices(true)) {

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

@@ -55,7 +55,7 @@ export declare const ClusterQueryDefinition: {
         }, input: {
             request?: import("../../../r-bridge/retriever").RParseRequests;
             parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
-        }) => import("../../../dataflow/info").DataflowInformation;
+        }, config: import("../../../config").FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
         readonly requiredInput: {};
         readonly name: "dataflow";
         readonly description: "Construct the dataflow graph";

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

@@ -1,3 +1,3 @@
 import type { ConfigQuery, ConfigQueryResult } from './config-query-format';
 import type { BasicQueryData } from '../../base-query-format';
-export declare function executeConfigQuery(_: BasicQueryData, queries: readonly ConfigQuery[]): ConfigQueryResult;
+export declare function executeConfigQuery({ config }: BasicQueryData, queries: readonly ConfigQuery[]): ConfigQueryResult;

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

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeConfigQuery = executeConfigQuery;
 const log_1 = require("../../../util/log");
-const config_1 = require("../../../config");
-function executeConfigQuery(_, queries) {
+function executeConfigQuery({ config }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Config query expects only up to one query, but got', queries.length);
     }
@@ -12,7 +11,7 @@ function executeConfigQuery(_, queries) {
             /* there is no sense in measuring a get */
             timing: 0
         },
-        config: (0, config_1.getConfig)()
+        config: config
     };
 }
 //# sourceMappingURL=config-query-executor.js.map

package/queries/catalog/control-flow-query/control-flow-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { ControlFlowQuery, ControlFlowQueryResult } from './control-flow-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeControlFlowQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly ControlFlowQuery[]): ControlFlowQueryResult;

package/queries/catalog/control-flow-query/control-flow-query-executor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeControlFlowQuery = executeControlFlowQuery;
+const log_1 = require("../../../util/log");
+const extract_cfg_1 = require("../../../control-flow/extract-cfg");
+function executeControlFlowQuery({ dataflow: { graph }, ast, config }, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('The control flow query expects only up to one query, but got', queries.length);
+    }
+    const query = queries[0];
+    const start = Date.now();
+    const controlFlow = (0, extract_cfg_1.extractCfg)(ast, config, graph, query.config?.simplificationPasses);
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        controlFlow
+    };
+}
+//# sourceMappingURL=control-flow-query-executor.js.map

package/queries/catalog/control-flow-query/control-flow-query-format.d.ts

@@ -0,0 +1,81 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeControlFlowQuery } from './control-flow-query-executor';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ControlFlowInformation } from '../../../control-flow/control-flow-graph';
+import type { CfgSimplificationPassName } from '../../../control-flow/cfg-simplification';
+/**
+ * Provides the control flow graph with an optional, fixed configuration
+ */
+export interface ControlFlowQuery extends BaseQueryFormat {
+    readonly type: 'control-flow';
+    readonly config?: {
+        /**
+         * If set, the control flow graph will be simplified using the given passes.
+         * Defaults to the default simplification order.
+         */
+        simplificationPasses?: readonly CfgSimplificationPassName[];
+    };
+}
+export interface ControlFlowQueryResult extends BaseQueryResult {
+    readonly controlFlow: ControlFlowInformation;
+}
+export declare const ControlFlowQueryDefinition: {
+    readonly executor: typeof executeControlFlowQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/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>;
+        }, config: import("../../../config").FlowrConfigOptions) => 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>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};

package/queries/catalog/control-flow-query/control-flow-query-format.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlFlowQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const control_flow_query_executor_1 = require("./control-flow-query-executor");
+const control_flow_graph_1 = require("../../../control-flow/control-flow-graph");
+const cfg_1 = require("../../../util/mermaid/cfg");
+const cfg_simplification_1 = require("../../../control-flow/cfg-simplification");
+exports.ControlFlowQueryDefinition = {
+    executor: control_flow_query_executor_1.executeControlFlowQuery,
+    asciiSummarizer: (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('control-flow', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        result.push(`   ╰ CFG: ${(0, cfg_1.cfgToMermaidUrl)(out.controlFlow, processed.normalize)}`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('control-flow').required().description('The type of the query.'),
+        config: joi_1.default.object({
+            simplificationPasses: joi_1.default.array().items(joi_1.default.string().valid(...Object.keys(cfg_simplification_1.CfgSimplificationPasses))).description('The simplification passes to apply to the control flow graph. If unset, the default simplification order will be used.')
+        }).optional().description('Optional configuration for the control flow query.')
+    }).description('The control flow query provides the control flow graph of the analysis, optionally simplified.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return [...out.controlFlow.graph.vertices(true)]
+            .filter(([, v]) => v.type !== control_flow_graph_1.CfgVertexType.Block)
+            .map(v => v[0]);
+    }
+};
+//# sourceMappingURL=control-flow-query-format.js.map

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-format.d.ts

@@ -54,7 +54,7 @@ export declare const DataflowLensQueryDefinition: {
         }, input: {
             request?: import("../../../r-bridge/retriever").RParseRequests;
             parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
-        }) => import("../../../dataflow/info").DataflowInformation;
+        }, config: import("../../../config").FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
         readonly requiredInput: {};
         readonly name: "dataflow";
         readonly description: "Construct the dataflow graph";

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

@@ -55,7 +55,7 @@ export declare const DataflowQueryDefinition: {
         }, input: {
             request?: import("../../../r-bridge/retriever").RParseRequests;
             parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
-        }) => import("../../../dataflow/info").DataflowInformation;
+        }, config: import("../../../config").FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
         readonly requiredInput: {};
         readonly name: "dataflow";
         readonly description: "Construct the dataflow graph";