@eagleoutice/flowr 2.2.13 → 2.2.15

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 }, 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, 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>;
+        }) => 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

@@ -69,4 +69,5 @@ export declare const DataflowLensQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -19,6 +19,7 @@ exports.DataflowLensQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('dataflow-lens').required().description('The type of the query.'),
-    }).description('The dataflow-lens query returns a simplified view on the dataflow graph')
+    }).description('The dataflow-lens query returns a simplified view on the dataflow graph'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=dataflow-lens-query-format.js.map

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

@@ -2,6 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 import { executeDataflowQuery } from './dataflow-query-executor';
 import Joi from 'joi';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Simple re-returns the dataflow graph of the analysis.
  */
@@ -69,4 +70,5 @@ export declare const DataflowQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -19,6 +19,14 @@ exports.DataflowQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('dataflow').required().description('The type of the query.'),
-    }).description('The dataflow query simply returns the dataflow graph, there is no need to pass it multiple times!')
+    }).description('The dataflow query simply returns the dataflow graph, there is no need to pass it multiple times!'),
+    flattenInvolvedNodes: queryResults => {
+        const flattened = [];
+        const out = queryResults;
+        for (const id of out.graph.idMap?.keys() ?? []) {
+            flattened.push(id);
+        }
+        return flattened;
+    }
 };
 //# sourceMappingURL=dataflow-query-format.js.map

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

@@ -11,13 +11,16 @@ const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-
 const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const assert_1 = require("../../../util/assert");
 const objects_1 = require("../../../util/objects");
-const resolve_by_name_1 = require("../../../dataflow/environments/resolve-by-name");
 const library_functions_1 = require("./function-info/library-functions");
 const source_functions_1 = require("./function-info/source-functions");
 const read_functions_1 = require("./function-info/read-functions");
 const write_functions_1 = require("./function-info/write-functions");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
+const r_value_1 = require("../../../dataflow/eval/values/r-value");
+const general_1 = require("../../../dataflow/eval/values/general");
+const alias_tracking_1 = require("../../../dataflow/eval/resolve/alias-tracking");
+const string_constants_1 = require("../../../dataflow/eval/values/string/string-constants");
 function collectNamespaceAccesses(data, libraries) {
     /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
     (0, visitor_1.visitAst)(data.ast.ast, n => {
@@ -203,31 +206,32 @@ function resolveBasedOnConfig(data, vertex, argument, environment, idMap, resolv
             full = false;
         }
     }
-    return (0, resolve_by_name_1.resolveIdToValue)(argument, { environment, graph: data.dataflow.graph, full });
-}
-function unwrapRValue(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    switch (typeof value) {
-        case 'string':
-            return value;
-        case 'number':
-            return value.toString();
-        case 'boolean':
-            return value ? 'TRUE' : 'FALSE';
-    }
-    if (typeof value !== 'object' || value === null) {
-        return JSON.stringify(value);
-    }
-    if ('str' in value) {
-        return value.str;
-    }
-    else if ('num' in value) {
-        return value.num.toString();
-    }
-    else {
-        return JSON.stringify(value);
+    full = true;
+    const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(argument, { environment, graph: data.dataflow.graph, full: full }));
+    if (resolved) {
+        const values = [];
+        for (const value of resolved.elements) {
+            if (!(0, r_value_1.isValue)(value)) {
+                return undefined;
+            }
+            if (value.type === 'string' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.str);
+            }
+            else if (value.type === 'logical' && (0, r_value_1.isValue)(value.value)) {
+                values.push(value.value.valueOf() ? 'TRUE' : 'FALSE');
+            }
+            else if (value.type === 'vector' && (0, r_value_1.isValue)(value.elements)) {
+                const elements = (0, string_constants_1.collectStrings)(value.elements);
+                if (elements === undefined) {
+                    return undefined;
+                }
+                values.push(...elements);
+            }
+            else {
+                return undefined;
+            }
+        }
+        return values;
     }
 }
 /**
@@ -254,16 +258,14 @@ function getArgumentValue(data, vertex, argumentIndex, argumentName, resolveValu
                 valueNode = valueNode.value;
             }
             if (valueNode) {
-                // TDODO: extend vector support etc.
                 // this should be evaluated in the callee-context
-                const values = resolveBasedOnConfig(data, vertex, valueNode, vertex.environment, graph.idMap, resolveValue)
-                    ?.map(unwrapRValue) ?? [dependencies_query_format_1.Unknown];
+                const values = resolveBasedOnConfig(data, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
                 map.set(ref, new Set(values));
             }
         }
         return map;
     }
-    if (vertex.args.length > argumentIndex) {
+    if (argumentIndex < vertex.args.length) {
         const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
         if (!arg) {
             return undefined;
@@ -273,8 +275,7 @@ function getArgumentValue(data, vertex, argumentIndex, argumentName, resolveValu
             valueNode = valueNode.value;
         }
         if (valueNode) {
-            const values = resolveBasedOnConfig(data, vertex, valueNode, vertex.environment, graph.idMap, resolveValue)
-                ?.map(unwrapRValue) ?? [dependencies_query_format_1.Unknown];
+            const values = resolveBasedOnConfig(data, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
             return new Map([[arg, new Set(values)]]);
         }
     }

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

@@ -94,4 +94,5 @@ export declare const DependenciesQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -53,6 +53,15 @@ exports.DependenciesQueryDefinition = {
         sourceFunctions: functionInfoSchema.description('The set of source functions to search for.'),
         readFunctions: functionInfoSchema.description('The set of data reading functions to search for.'),
         writeFunctions: functionInfoSchema.description('The set of data writing functions to search for.'),
-    }).description('The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data.')
+    }).description('The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return [
+            ...out.libraries.map(library => library.nodeId),
+            ...out.sourcedFiles.map(sourced => sourced.nodeId),
+            ...out.readData.map(read => read.nodeId),
+            ...out.writtenData.map(write => write.nodeId)
+        ];
+    }
 };
 //# sourceMappingURL=dependencies-query-format.js.map

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

@@ -68,4 +68,5 @@ export declare const HappensBeforeQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -22,6 +22,7 @@ exports.HappensBeforeQueryDefinition = {
         type: joi_1.default.string().valid('happens-before').required().description('The type of the query.'),
         a: joi_1.default.string().required().description('The first slicing criterion.'),
         b: joi_1.default.string().required().description('The second slicing criterion.')
-    }).description('Happens-Before tracks whether a always happens before b.')
+    }).description('Happens-Before tracks whether a always happens before b.'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=happens-before-query-format.js.map

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

@@ -65,4 +65,5 @@ export declare const IdMapQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -19,6 +19,7 @@ exports.IdMapQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('id-map').required().description('The type of the query.'),
-    }).description('The id map query retrieves the id map from the normalized AST.')
+    }).description('The id map query retrieves the id map from the normalized AST.'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=id-map-query-format.js.map

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

@@ -71,4 +71,5 @@ export declare const LineageQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -22,6 +22,10 @@ exports.LineageQueryDefinition = {
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('lineage').required().description('The type of the query.'),
         criterion: joi_1.default.string().required().description('The slicing criterion of the node to get the lineage of.')
-    }).description('Lineage query used to find the lineage of a node in the dataflow graph')
+    }).description('Lineage query used to find the lineage of a node in the dataflow graph'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.values(out.lineages).flatMap(lineage => [...lineage]);
+    }
 };
 //# sourceMappingURL=lineage-query-format.js.map

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

@@ -0,0 +1,3 @@
+import type { BasicQueryData } from '../../base-query-format';
+import type { LinterQuery, LinterQueryResult } from './linter-query-format';
+export declare function executeLinterQuery({ ast, dataflow }: BasicQueryData, queries: readonly LinterQuery[]): LinterQueryResult;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLinterQuery = executeLinterQuery;
+const linter_rules_1 = require("../../../linter/linter-rules");
+const log_1 = require("../../../util/log");
+const linter_executor_1 = require("../../../linter/linter-executor");
+function executeLinterQuery({ ast, dataflow }, queries) {
+    const flattened = queries.flatMap(q => q.rules ?? Object.keys(linter_rules_1.LintingRules));
+    const distinct = new Set(flattened);
+    if (distinct.size !== flattened.length) {
+        const pretty = [...distinct].filter(r => flattened.indexOf(r) !== flattened.lastIndexOf(r)).map(r => typeof r === 'string' ? r : r.name).join(', ');
+        log_1.log.warn(`Linter query collection contains duplicate rules ${pretty}, only linting for each rule once`);
+    }
+    const results = { results: {} };
+    const start = Date.now();
+    const input = { normalize: ast, dataflow };
+    for (const entry of distinct) {
+        const ruleName = typeof entry === 'string' ? entry : entry.name;
+        results.results[ruleName] = (0, linter_executor_1.executeLintingRule)(ruleName, input, entry?.config);
+    }
+    return {
+        ...results,
+        '.meta': {
+            timing: Date.now() - start
+        }
+    };
+}
+//# sourceMappingURL=linter-query-executor.js.map

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

@@ -0,0 +1,80 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeLinterQuery } from './linter-query-executor';
+import type { LintingRuleNames } from '../../../linter/linter-rules';
+import type { ConfiguredLintingRule, LintingResults } from '../../../linter/linter-format';
+export interface LinterQuery extends BaseQueryFormat {
+    readonly type: 'linter';
+    /**
+     * The rules to lint for. If unset, all rules will be included.
+     * Optionally, a {@link ConfiguredLintingRule} can be provided, which additionally includes custom user-supplied values for the linting rules' configurations.
+     */
+    readonly rules?: (LintingRuleNames | ConfiguredLintingRule)[];
+}
+export interface LinterQueryResult extends BaseQueryResult {
+    /**
+     * The results of the linter query, which returns a set of linting results for each rule that was executed.
+     */
+    readonly results: {
+        [L in LintingRuleNames]?: LintingResults<L>;
+    };
+}
+export declare const LinterQueryDefinition: {
+    readonly executor: typeof executeLinterQuery;
+    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>;
+        }) => 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: () => never[];
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinterQueryDefinition = void 0;
+const joi_1 = __importDefault(require("joi"));
+const linter_query_executor_1 = require("./linter-query-executor");
+const linter_rules_1 = require("../../../linter/linter-rules");
+const linter_format_1 = require("../../../linter/linter-format");
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+const doc_code_1 = require("../../../documentation/doc-util/doc-code");
+exports.LinterQueryDefinition = {
+    executor: linter_query_executor_1.executeLinterQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('linter', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [ruleName, results] of Object.entries(out.results)) {
+            const rule = linter_rules_1.LintingRules[ruleName];
+            result.push(`   ╰ ${ruleName}:`);
+            for (const certainty of [linter_format_1.LintingCertainty.Definitely, linter_format_1.LintingCertainty.Maybe]) {
+                const certaintyResults = results.results.filter(r => r.certainty === certainty);
+                if (certaintyResults.length) {
+                    result.push(`       ╰ ${certainty}:`);
+                    for (const res of certaintyResults) {
+                        result.push(`           ╰ ${rule.prettyPrint(res)}`);
+                    }
+                }
+            }
+            result.push(`       ╰ _Metadata_: ${(0, doc_code_1.codeInline)(JSON.stringify(results['.meta']))}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('linter').required().description('The type of the query.'),
+        rules: joi_1.default.array().items(joi_1.default.string().valid(...Object.keys(linter_rules_1.LintingRules)), joi_1.default.object({
+            name: joi_1.default.string().valid(...Object.keys(linter_rules_1.LintingRules)).required(),
+            config: joi_1.default.object()
+        })).description('The rules to lint for. If unset, all rules will be included.')
+    }).description('The linter query lints for the given set of rules and returns the result.'),
+    flattenInvolvedNodes: () => []
+};
+//# sourceMappingURL=linter-query-format.js.map

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

@@ -23,4 +23,5 @@ export declare const LocationMapQueryDefinition: {
     readonly executor: typeof executeLocationMapQuery;
     readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

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

@@ -23,6 +23,7 @@ exports.LocationMapQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('location-map').required().description('The type of the query.'),
-    }).description('The location map query retrieves the location of every id in the ast.')
+    }).description('The location map query retrieves the location of every id in the ast.'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=location-map-query-format.js.map

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.d.ts

@@ -68,4 +68,5 @@ export declare const NormalizedAstQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.js

@@ -19,6 +19,7 @@ exports.NormalizedAstQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('normalized-ast').required().description('The type of the query.'),
-    }).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!')
+    }).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=normalized-ast-query-format.js.map

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

@@ -3,6 +3,7 @@ import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import Joi from 'joi';
 import { executeResolveValueQuery } from './origin-query-executor';
 import type { Origin } from '../../../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export interface OriginQuery extends BaseQueryFormat {
     readonly type: 'origin';
     /** The slicing criteria to use */
@@ -68,4 +69,5 @@ export declare const OriginQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -22,6 +22,10 @@ exports.OriginQueryDefinition = {
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('origin').required().description('The type of the query.'),
         criterion: joi_1.default.string().required().description('The slicing criteria to use'),
-    }).description('The resolve value query used to get definitions of an identifier')
+    }).description('The resolve value query used to get definitions of an identifier'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.entries(out.results).flatMap(([_, obj]) => obj?.map(origin => origin.id) ?? []);
+    }
 };
 //# sourceMappingURL=origin-query-format.js.map

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

@@ -4,7 +4,7 @@ exports.executeProjectQuery = executeProjectQuery;
 const log_1 = require("../../../util/log");
 function executeProjectQuery({ dataflow }, queries) {
     if (queries.length !== 1) {
-        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+        log_1.log.warn('Project query expects only up to one query, but got', queries.length);
     }
     return {
         '.meta': {

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

@@ -64,4 +64,5 @@ export declare const ProjectQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };