@eagleoutice/flowr 2.2.15 → 2.3.0

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

@@ -1,3 +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 }: BasicQueryData, queries: readonly ControlFlowQuery[]): ControlFlowQueryResult;
+export declare function executeControlFlowQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly ControlFlowQuery[]): ControlFlowQueryResult;

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

@@ -3,13 +3,13 @@ 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) {
+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, graph, query.config?.simplificationPasses);
+    const controlFlow = (0, extract_cfg_1.extractCfg)(ast, config, graph, query.config?.simplificationPasses);
     return {
         '.meta': {
             timing: Date.now() - start

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

@@ -62,7 +62,7 @@ export declare const ControlFlowQueryDefinition: {
         }, 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-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";

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

@@ -4,12 +4,9 @@ exports.executeDependenciesQuery = executeDependenciesQuery;
 const query_1 = require("../../query");
 const dependencies_query_format_1 = require("./dependencies-query-format");
 const vertex_1 = require("../../../dataflow/graph/vertex");
-const graph_1 = require("../../../dataflow/graph/graph");
 const log_1 = require("../../../util/log");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 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 library_functions_1 = require("./function-info/library-functions");
 const source_functions_1 = require("./function-info/source-functions");
@@ -17,10 +14,7 @@ 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");
+const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 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 => {
@@ -29,7 +23,7 @@ function collectNamespaceAccesses(data, libraries) {
             libraries.push({
                 nodeId: n.info.id,
                 functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
-                libraryName: n.namespace
+                libraryName: n.namespace,
             });
         }
     });
@@ -119,7 +113,7 @@ function getResults(data, results, kind, functions, makeInfo) {
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
         const vertex = data.dataflow.graph.getVertex(id);
         const info = functions.find(f => f.name === name);
-        const args = getArgumentValue(data, vertex, info.argIdx, info.argName, info.resolveValue);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
         const linkedArgs = collectValuesFromLinks(args, data, linkedIds);
         const foundValues = linkedArgs ?? args;
         if (!foundValues) {
@@ -161,7 +155,7 @@ function collectValuesFromLinks(args, data, linkedIds) {
         if (vertex === undefined || vertex.tag !== vertex_1.VertexType.FunctionCall) {
             continue;
         }
-        const args = getArgumentValue(data, vertex, info.argIdx, info.argName, info.resolveValue);
+        const args = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, info.argIdx, info.argName, info.resolveValue);
         if (args === undefined) {
             continue;
         }
@@ -175,112 +169,6 @@ function collectValuesFromLinks(args, data, linkedIds) {
     }
     return map.size ? map : undefined;
 }
-function hasCharacterOnly(data, vertex, idMap) {
-    if (!vertex.args || vertex.args.length === 0 || !idMap) {
-        return false;
-    }
-    const treatAsChar = getArgumentValue(data, vertex, 5, 'character.only', true);
-    if (!treatAsChar) {
-        return false;
-    }
-    const hasTrue = [...treatAsChar.values()].some(set => set?.has('TRUE'));
-    const hasFalse = hasTrue ? [...treatAsChar.values()].some(set => set === undefined || set.has('FALSE')) : false;
-    if (hasTrue && hasFalse) {
-        return 'maybe';
-    }
-    else {
-        return hasTrue;
-    }
-}
-function resolveBasedOnConfig(data, vertex, argument, environment, idMap, resolveValue) {
-    let full = true;
-    if (!resolveValue) {
-        full = false;
-    }
-    if (resolveValue === 'library') {
-        const hasChar = hasCharacterOnly(data, vertex, idMap);
-        if (hasChar === false) {
-            if (argument.type === type_1.RType.Symbol) {
-                return [argument.lexeme];
-            }
-            full = false;
-        }
-    }
-    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;
-    }
-}
-/**
- * Get the values of all arguments matching the criteria.
- */
-function getArgumentValue(data, vertex, argumentIndex, argumentName, resolveValue) {
-    const graph = data.dataflow.graph;
-    if (argumentName) {
-        const arg = vertex?.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argumentName);
-        if (arg >= 0) {
-            argumentIndex = arg;
-        }
-    }
-    if (!vertex || argumentIndex === undefined) {
-        return undefined;
-    }
-    if (argumentIndex === 'unnamed') {
-        // return all unnamed arguments
-        const references = vertex.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument).filter(assert_1.isNotUndefined);
-        const map = new Map();
-        for (const ref of references) {
-            let valueNode = graph.idMap?.get(ref);
-            if (valueNode?.type === type_1.RType.Argument) {
-                valueNode = valueNode.value;
-            }
-            if (valueNode) {
-                // this should be evaluated in the callee-context
-                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 (argumentIndex < vertex.args.length) {
-        const arg = (0, graph_1.getReferenceOfArgument)(vertex.args[argumentIndex]);
-        if (!arg) {
-            return undefined;
-        }
-        let valueNode = graph.idMap?.get(arg);
-        if (valueNode?.type === type_1.RType.Argument) {
-            valueNode = valueNode.value;
-        }
-        if (valueNode) {
-            const values = resolveBasedOnConfig(data, vertex, valueNode, vertex.environment, graph.idMap, resolveValue) ?? [dependencies_query_format_1.Unknown];
-            return new Map([[arg, new Set(values)]]);
-        }
-    }
-    return undefined;
-}
 function getFunctionsToCheck(customFunctions, ignoreDefaultFunctions, defaultFunctions) {
     let functions = ignoreDefaultFunctions ? [] : [...defaultFunctions];
     if (customFunctions) {

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

@@ -79,7 +79,7 @@ export declare const DependenciesQueryDefinition: {
         }, 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/df-shape-query/df-shape-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { DfShapeQuery, DfShapeQueryResult } from './df-shape-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeDfShapeQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly DfShapeQuery[]): DfShapeQueryResult;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDfShapeQuery = executeDfShapeQuery;
+const log_1 = require("../../../util/log");
+const extract_cfg_1 = require("../../../control-flow/extract-cfg");
+const shape_inference_1 = require("../../../abstract-interpretation/data-frame/shape-inference");
+const parse_1 = require("../../../slicing/criterion/parse");
+function executeDfShapeQuery({ dataflow: { graph }, ast, config }, queries) {
+    if (queries.length !== 1 && queries.some(query => query.criterion === undefined)) {
+        log_1.log.warn('The dataframe shape query expects only up to one query without slicing criterion, but got', queries.length);
+        queries = [{ type: 'df-shape' }];
+    }
+    const start = Date.now();
+    const cfg = (0, extract_cfg_1.extractCfg)(ast, config, graph);
+    const domains = (0, shape_inference_1.inferDataFrameShapes)(cfg, graph, ast, config);
+    if (queries.length === 1 && queries[0].criterion === undefined) {
+        return {
+            '.meta': {
+                timing: Date.now() - start
+            },
+            domains: domains
+        };
+    }
+    const result = new Map();
+    for (const query of queries) {
+        if (query.criterion === undefined) {
+            log_1.log.warn('Missing criterion in dataframe shape query');
+            continue;
+        }
+        else if (result.has(query.criterion)) {
+            log_1.log.warn('Duplicate criterion in dataframe shape query:', query.criterion);
+            continue;
+        }
+        const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
+        const node = ast.idMap.get(nodeId);
+        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node?.info.id, graph);
+        result.set(query.criterion, value);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        domains: result
+    };
+}
+//# sourceMappingURL=df-shape-query-executor.js.map

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

@@ -0,0 +1,72 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { DataFrameDomain, DataFrameStateDomain } from '../../../abstract-interpretation/data-frame/domain';
+import { executeDfShapeQuery } from './df-shape-query-executor';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+/** Infer the shape of data frames using abstract interpretation. */
+export interface DfShapeQuery extends BaseQueryFormat {
+    readonly type: 'df-shape';
+    readonly criterion?: SingleSlicingCriterion;
+}
+export interface DfShapeQueryResult extends BaseQueryResult {
+    domains: DataFrameStateDomain | Map<SingleSlicingCriterion, DataFrameDomain | undefined>;
+}
+export declare const DfShapeQueryDefinition: {
+    readonly executor: typeof executeDfShapeQuery;
+    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: () => never[];
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfShapeQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+const joi_1 = __importDefault(require("joi"));
+const df_shape_query_executor_1 = require("./df-shape-query-executor");
+const json_1 = require("../../../util/json");
+exports.DfShapeQueryDefinition = {
+    executor: df_shape_query_executor_1.executeDfShapeQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(...out.domains.entries().take(20).map(([key, domain]) => {
+            return `   ╰ ${key}: ${JSON.stringify(domain, json_1.jsonReplacer)}`;
+        }));
+        if (out.domains.size > 20) {
+            result.push('   ╰ ... (see JSON)');
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('df-shape').required().description('The type of the query.'),
+        criterion: joi_1.default.string().optional().description('The slicing criterion of the node to get the dataframe shape for.')
+    }).description('The df-shape query retrieves information on the shape of dataframes'),
+    flattenInvolvedNodes: () => []
+};
+//# sourceMappingURL=df-shape-query-format.js.map

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

@@ -53,7 +53,7 @@ export declare const HappensBeforeQueryDefinition: {
         }, 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/id-map-query/id-map-query-format.d.ts

@@ -50,7 +50,7 @@ export declare const IdMapQueryDefinition: {
         }, 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/lineage-query/lineage-query-format.d.ts

@@ -56,7 +56,7 @@ export declare const LineageQueryDefinition: {
         }, 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/linter-query/linter-query-executor.d.ts

@@ -1,3 +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;
+export declare function executeLinterQuery({ ast, dataflow, config }: BasicQueryData, queries: readonly LinterQuery[]): LinterQueryResult;

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

@@ -4,7 +4,7 @@ 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) {
+function executeLinterQuery({ ast, dataflow, config }, queries) {
     const flattened = queries.flatMap(q => q.rules ?? Object.keys(linter_rules_1.LintingRules));
     const distinct = new Set(flattened);
     if (distinct.size !== flattened.length) {
@@ -13,7 +13,7 @@ function executeLinterQuery({ ast, dataflow }, queries) {
     }
     const results = { results: {} };
     const start = Date.now();
-    const input = { normalize: ast, dataflow };
+    const input = { normalize: ast, dataflow, config };
     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);

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

@@ -61,7 +61,7 @@ export declare const LinterQueryDefinition: {
         }, 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/linter-query/linter-query-format.js

@@ -17,18 +17,7 @@ exports.LinterQueryDefinition = {
         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']))}`);
+            addLintingRuleResult(ruleName, results, result);
         }
         return true;
     },
@@ -41,4 +30,19 @@ exports.LinterQueryDefinition = {
     }).description('The linter query lints for the given set of rules and returns the result.'),
     flattenInvolvedNodes: () => []
 };
+function addLintingRuleResult(ruleName, results, result) {
+    const rule = linter_rules_1.LintingRules[ruleName];
+    result.push(`   ╰ **${rule.info.name}** (${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) {
+                const pretty = rule.prettyPrint[linter_format_1.LintingPrettyPrintContext.Query](res, results['.meta']);
+                result.push(`           ╰ ${pretty}${res.quickFix ? ` (${res.quickFix.length} quick fix(es) available)` : ''}`);
+            }
+        }
+    }
+    result.push(`       ╰ _Metadata_: ${(0, doc_code_1.codeInline)(JSON.stringify(results['.meta']))}`);
+}
 //# sourceMappingURL=linter-query-format.js.map

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

@@ -53,7 +53,7 @@ export declare const NormalizedAstQueryDefinition: {
         }, 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/origin-query/origin-query-format.d.ts

@@ -54,7 +54,7 @@ export declare const OriginQueryDefinition: {
         }, 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/project-query/project-query-format.d.ts

@@ -49,7 +49,7 @@ export declare const ProjectQueryDefinition: {
         }, 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/resolve-value-query/resolve-value-query-executor.d.ts

@@ -1,4 +1,4 @@
 import type { ResolveValueQuery, ResolveValueQueryResult } from './resolve-value-query-format';
 import type { BasicQueryData } from '../../base-query-format';
 export declare function fingerPrintOfQuery(query: ResolveValueQuery): string;
-export declare function executeResolveValueQuery({ dataflow: { graph }, ast }: BasicQueryData, queries: readonly ResolveValueQuery[]): ResolveValueQueryResult;
+export declare function executeResolveValueQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly ResolveValueQuery[]): ResolveValueQueryResult;

package/queries/catalog/resolve-value-query/resolve-value-query-executor.js

@@ -8,7 +8,7 @@ const alias_tracking_1 = require("../../../dataflow/eval/resolve/alias-tracking"
 function fingerPrintOfQuery(query) {
     return JSON.stringify(query);
 }
-function executeResolveValueQuery({ dataflow: { graph }, ast }, queries) {
+function executeResolveValueQuery({ dataflow: { graph }, ast, config }, queries) {
     const start = Date.now();
     const results = {};
     for (const query of queries) {
@@ -18,7 +18,7 @@ function executeResolveValueQuery({ dataflow: { graph }, ast }, queries) {
         }
         const values = query.criteria
             .map(criteria => (0, parse_1.slicingCriterionToId)(criteria, ast.idMap))
-            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap }));
+            .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap: ast.idMap, resolve: config.solver.variables }));
         results[key] = {
             values: values
         };

package/queries/catalog/resolve-value-query/resolve-value-query-format.d.ts

@@ -55,7 +55,7 @@ export declare const ResolveValueQueryDefinition: {
         }, 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/search-query/search-query-executor.d.ts

@@ -1,3 +1,3 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { SearchQuery, SearchQueryResult } from './search-query-format';
-export declare function executeSearch({ ast, dataflow }: BasicQueryData, queries: readonly SearchQuery[]): SearchQueryResult;
+export declare function executeSearch({ ast, dataflow, config }: BasicQueryData, queries: readonly SearchQuery[]): SearchQueryResult;

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

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeSearch = executeSearch;
 const flowr_search_executor_1 = require("../../../search/flowr-search-executor");
-function executeSearch({ ast, dataflow }, queries) {
+function executeSearch({ ast, dataflow, config }, queries) {
     const start = Date.now();
     const results = [];
     for (const query of queries) {
         const { search } = query;
         results.push({
-            ids: (0, flowr_search_executor_1.runSearch)(search, { normalize: ast, dataflow })
+            ids: (0, flowr_search_executor_1.runSearch)(search, { normalize: ast, dataflow, config })
                 .map(({ node }) => node.info.id),
             search
         });