feat(query): add resolve value query - #1107

src/queries/catalog/resolve-value-query/resolve-value-query-executor.ts

@@ -0,0 +1,47 @@
+import type { ResolveValueQuery, ResolveValueQueryResult } from './resolve-value-query-format';
+import { staticSlicing } from '../../../slicing/static/static-slicer';
+import { reconstructToCode } from '../../../reconstruct/reconstruct';
+import { doNotAutoSelect } from '../../../reconstruct/auto-select/auto-select-defaults';
+import { makeMagicCommentHandler } from '../../../reconstruct/auto-select/magic-comments';
+import { log } from '../../../util/log';
+import type { BasicQueryData } from '../../base-query-format';
+import { slicingCriterionToId } from '../../../slicing/criterion/parse';
+import { resolveToValues } from '../../../dataflow/environments/resolve-by-name';
+import { recoverName } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+
+export function fingerPrintOfQuery(query: ResolveValueQuery): string {
+	return JSON.stringify(query);
+}
+
+export function executeResolveValueQuery({ dataflow: { graph, environment }, ast }: BasicQueryData, queries: readonly ResolveValueQuery[]): ResolveValueQueryResult {
+	const start = Date.now();
+	const results: ResolveValueQueryResult['results'] = [];
+	for(const query of queries) {
+		const key = fingerPrintOfQuery(query);
+
+		if(results[key]) {
+			log.warn(`Duplicate Key for slicing-query: ${key}, skipping...`);
+		}
+
+		const ids = query.criteria.map(criteria => slicingCriterionToId(criteria, graph.idMap!));
+		const values = new Set<unknown>();
+
+		const resolveStart = Date.now();
+		for(const id of ids) {
+			resolveToValues(recoverName(id, graph.idMap),  environment, graph)
+			?.forEach(values.add);
+		}
+		const resolveEnd = Date.now();
+
+		results[key] = {
+			values: values.values(),
+			'.meta': { timing: resolveEnd - resolveStart }
+		}
+	}
+	return {
+		'.meta': {
+			timing: Date.now() - start
+		},
+		results
+	};
+}

src/queries/catalog/resolve-value-query/resolve-value-query-format.ts

@@ -0,0 +1,43 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
+import type {
+	DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE,
+	DEFAULT_SLICING_PIPELINE
+} from '../../../core/steps/pipeline/default-pipelines';
+import type { SlicingCriteria } from '../../../slicing/criterion/parse';
+import type { QueryResults, SupportedQuery } from '../../query';
+import { bold } from '../../../util/ansi';
+import { printAsMs } from '../../../util/time';
+import Joi from 'joi';
+
+import { summarizeIdsIfTooLong } from '../../query-print';
+import { executeResolveValueQuery } from './resolve-value-query-executor';
+
+
+export interface ResolveValueQuery extends BaseQueryFormat {
+	readonly type:              'resolve-value';
+	/** The slicing criteria to use */
+	readonly criteria:          SlicingCriteria,
+}
+
+export interface ResolveValueQueryResult extends BaseQueryResult {
+	results: Record<string, any>
+}
+
+export const ResolveValueQueryDefinition = {
+	executor:        executeResolveValueQuery,
+	asciiSummarizer: (formatter, _processed, queryResults, result) => {
+		const out = queryResults as QueryResults<'resolve-value'>['resolve-value'];
+		result.push(`Query: ${bold('resolve-value', formatter)} (${printAsMs(out['.meta'].timing, 0)})`);
+		for(const [fingerprint, obj] of Object.entries(out.results)) {
+			const { criteria } = JSON.parse(fingerprint) as ResolveValueQuery;
+			result.push(`   ╰ Values for {${criteria.join(', ')}}`);
+			result.push(`   	╰ ${obj.values.join(', ')}`);
+		}
+		return true;
+	},
+	schema: Joi.object({
+		type:             Joi.string().valid('resolve-value').required().description('The type of the query.'),
+		criteria:         Joi.array().items(Joi.string()).min(0).required().description('The slicing criteria to use.'),
+	}).description('Resolve Value query used to get definitions of an identifier')
+} as const satisfies SupportedQuery<'resolve-value'>;

src/queries/query.ts

@@ -35,6 +35,7 @@ import type {
 import {
 	HappensBeforeQueryDefinition
 } from './catalog/happens-before-query/happens-before-query-format';
+import { ResolveValueQuery, ResolveValueQueryDefinition } from './catalog/resolve-value-query/resolve-value-query-format';
 
 export type Query = CallContextQuery
 	| ConfigQuery
@@ -47,7 +48,8 @@ export type Query = CallContextQuery
 	| LineageQuery
 	| DependenciesQuery
 	| LocationMapQuery
-	| HappensBeforeQuery;
+	| HappensBeforeQuery
+	| ResolveValueQuery;
 
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & { type: QueryType };
 
@@ -76,7 +78,8 @@ export const SupportedQueries = {
 	'dependencies':     DependenciesQueryDefinition,
 	'location-map':     LocationMapQueryDefinition,
 	'search':           SearchQueryDefinition,
-	'happens-before':   HappensBeforeQueryDefinition
+	'happens-before':   HappensBeforeQueryDefinition,
+	'resolve-value': ResolveValueQueryDefinition
 } as const satisfies SupportedQueries;
 
 export type SupportedQueryTypes = keyof typeof SupportedQueries;