[Abstract Domains IV] A resolve value query

src/documentation/print-query-wiki.ts

@@ -221,6 +221,28 @@ ${
 	}
 });
 
+registerQueryDocumentation('resolve-value', {
+	name:             'Resolve Value Query',
+	type:             'active',
+	shortDescription: 'Provides access to flowR\'s alias tracking',
+	functionName:     executeSearch.name,
+	functionFile:     '../queries/catalog/resolve-value-query/resolve-value-query-executor.ts',
+	buildExplanation: async(shell: RShell) => {
+		const exampleCode = 'x <- 1\nprint(x)';
+		return `
+With this query you can use flowR's alias-tracking capabilities to resolve identifiers to their values. 
+
+Using the example code \`${exampleCode}\`, the following query returns all values of 'x' in the code:
+${
+	await showQuery(shell, exampleCode, [{
+		type:     'resolve-value',
+		criteria: ['2@x']
+	}], { showCode: true })
+}
+		`;
+	}
+});
+
 registerQueryDocumentation('search', {
 	name:             'Search Query',
 	type:             'active',

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

@@ -0,0 +1,43 @@
+import type { ResolveValueQuery, ResolveValueQueryResult } from './resolve-value-query-format';
+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 } }: BasicQueryData, queries: readonly ResolveValueQuery[]): ResolveValueQueryResult {
+	const idMap = graph.idMap;
+
+	if(!idMap) {
+		throw new Error('idMap was undefined');
+	}
+
+	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 values = query.criteria
+			.map(criteria => recoverName(slicingCriterionToId(criteria, idMap), idMap))
+			.flatMap(ident => resolveToValues(ident, environment, graph));
+
+		results[key] = {
+			values: [... new Set(values)]
+		};
+	}
+
+	return {
+		'.meta': {
+			timing: Date.now() - start
+		},
+		results
+	};
+}

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

@@ -0,0 +1,58 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+
+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 { executeResolveValueQuery } from './resolve-value-query-executor';
+import type { RNumberValue, RStringValue } from '../../../r-bridge/lang-4.x/convert-values';
+
+
+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, {values: unknown[]}>
+}
+
+function rValueToAscii(value: string | RNumberValue | RStringValue): string {
+	if(value === null || value === undefined) {
+		return 'undefined';
+	} else if(typeof value === 'string') {
+		return value;
+	} else if(typeof value === 'object') {	
+		if('num' in value) {
+			return value.num.toString();
+		} else if('str' in value) {
+			return `${value.quotes}${value.str}${value.quotes}`;
+		} else {
+			console.warn('omega lul');
+			return JSON.stringify(value);
+		}
+	} 
+
+	return value;
+}
+
+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.map(v => rValueToAscii(v as string | RNumberValue | RStringValue)).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,8 @@ import type {
 import {
 	HappensBeforeQueryDefinition
 } from './catalog/happens-before-query/happens-before-query-format';
+import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
+import { ResolveValueQueryDefinition } from './catalog/resolve-value-query/resolve-value-query-format';
 
 export type Query = CallContextQuery
 	| ConfigQuery
@@ -47,7 +49,8 @@ export type Query = CallContextQuery
 	| LineageQuery
 	| DependenciesQuery
 	| LocationMapQuery
-	| HappensBeforeQuery;
+	| HappensBeforeQuery
+	| ResolveValueQuery;
 
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & { type: QueryType };
 
@@ -76,7 +79,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;

test/functionality/dataflow/query/resolve-value-query.test.ts

@@ -0,0 +1,41 @@
+import { assertQuery } from '../../_helper/query';
+import { label } from '../../_helper/label';
+import { withShell } from '../../_helper/shell';
+import { assert, describe } from 'vitest';
+import type { ResolveValueQuery, ResolveValueQueryResult } from '../../../../src/queries/catalog/resolve-value-query/resolve-value-query-format';
+import { fingerPrintOfQuery } from '../../../../src/queries/catalog/resolve-value-query/resolve-value-query-executor';
+import { resolveToValues } from '../../../../src/dataflow/environments/resolve-by-name';
+import { slicingCriterionToId } from '../../../../src/slicing/criterion/parse';
+import { recoverName } from '../../../../src/r-bridge/lang-4.x/ast/model/processing/node-id';
+
+describe.sequential('Resolve Value Query', withShell(shell => {
+	function testQuery(name: string, code: string, queries: readonly ResolveValueQuery[]) {
+		assertQuery(label(name), shell, code, queries, ({ dataflow }) => {
+			const results: ResolveValueQueryResult['results'] = {};
+
+			const idMap = dataflow.graph.idMap;
+			assert(idMap !== undefined);
+
+			for(const query of queries) {
+				const key = fingerPrintOfQuery(query);
+				const identifiers = query.criteria
+					.map(criteria => slicingCriterionToId(criteria, idMap))
+					.map(id => recoverName(id, idMap));
+
+				const values = identifiers
+					.flatMap(id => resolveToValues(id, dataflow.environment, dataflow.graph));
+
+				results[key] = {
+					values: [... new Set(values)]
+				};
+			}
+
+			return {
+				'resolve-value': { results }
+			};
+		});
+	}
+
+	testQuery('Single dataflow', 'x <- 1', [{ type: 'resolve-value', criteria: ['1@x'] }]);
+	testQuery('Multiple Queries', 'x <- 1', [{ type: 'resolve-value', criteria: ['1@x'] }, { type: 'resolve-value', criteria: ['1@x'] }, { type: 'resolve-value', criteria: ['1@x'] }]);
+}));