Add type inference

src/documentation/print-query-wiki.ts

@@ -36,6 +36,7 @@ import { Q } from '../search/flowr-search-builder';
 import { VertexType } from '../dataflow/graph/vertex';
 import { getTypesFromFolderAsMermaid, shortLink } from './doc-util/doc-types';
 import path from 'path';
+import { executeDatatypeQuery } from '../queries/catalog/datatype-query/datatype-query-executor';
 import { executeControlFlowQuery } from '../queries/catalog/control-flow-query/control-flow-query-executor';
 import { printCfgCode } from './doc-util/doc-cfg';
 
@@ -483,6 +484,30 @@ This query replaces the old [\`request-slice\`](${FlowrWikiBaseRef}/Interface#me
 	}
 });
 
+
+registerQueryDocumentation('datatype', {
+	name:             'Datatype Query',
+	type:             'active',
+	shortDescription: 'Returns all datatypes for syntactic elements (or the type for a criterion).',
+	functionName:     executeDatatypeQuery.name,
+	functionFile:     '../queries/catalog/datatype-query/datatype-query-executor.ts',
+	buildExplanation: async(shell: RShell) => {
+		const exampleCode = 'x <- 1\ny <- 2\nx';
+		return `
+This query returns the datatypes of syntactic elements in the code.
+To exemplify the capabilities, consider the following code:
+${codeBlock('r', exampleCode)}
+To see the type of the variable \`x\`, you can use the following query:
+${
+	await showQuery(shell, exampleCode, [{
+		type:      'datatype',
+		criterion: '3@x'
+	}], { showCode: false })
+}
+`;
+	}
+});
+
 registerQueryDocumentation('dependencies', {
 	name:             'Dependencies Query',
 	type:             'active',

src/queries/catalog/datatype-query/datatype-query-executor.ts

@@ -0,0 +1,30 @@
+import type { DatatypeQuery, DatatypeQueryResult } from './datatype-query-format';
+import { log } from '../../../util/log';
+import type { BasicQueryData } from '../../base-query-format';
+import type { NormalizedAst, ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { slicingCriterionToId } from '../../../slicing/criterion/parse';
+import { inferDataTypes } from '../../../typing/infer';
+
+export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
+	const start = Date.now();
+	const result: DatatypeQueryResult['inferredTypes'] = {};
+	const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
+
+	for(const { criterion } of queries) {
+		if(result[criterion ?? '1:1'] !== undefined) {
+			log.warn('Duplicate criterion in datatype query:', criterion);
+			continue;
+		}
+		const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
+		if(node === undefined) {
+			log.warn('Criterion not found in normalized AST:', criterion);
+			continue;
+		}
+		result[criterion ?? '1:1'] = node.info.inferredType;
+	}
+
+	return {
+		'.meta':       { timing: Date.now() - start },
+		inferredTypes: result
+	};
+}

src/queries/catalog/datatype-query/datatype-query-format.ts

@@ -0,0 +1,42 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { QueryResults, SupportedQuery } from '../../query';
+import { bold } from '../../../util/text/ansi';
+import { printAsMs } from '../../../util/text/time';
+import Joi from 'joi';
+import { executeDatatypeQuery } from './datatype-query-executor';
+
+import { asciiDataType } from '../../query-print';
+import type { RDataType } from '../../../typing/types';
+
+/**
+ * Calculates the inferred data type for the given criterion.
+ */
+export interface DatatypeQuery extends BaseQueryFormat {
+	readonly type:       'datatype';
+	readonly criterion?: SingleSlicingCriterion;
+}
+
+export interface DatatypeQueryResult extends BaseQueryResult {
+	/** Maps each criterion to the inferred data type, duplicates are ignored. */
+	readonly inferredTypes: Record<SingleSlicingCriterion, RDataType>;
+}
+
+export const DatatypeQueryDefinition = {
+	executor:        executeDatatypeQuery,
+	asciiSummarizer: (formatter, _processed, queryResults, result) => {
+		const out = queryResults as QueryResults<'datatype'>['datatype'];
+		result.push(`Query: ${bold('datatype', formatter)} (${printAsMs(out['.meta'].timing, 0)})`);
+		for(const [criterion, inferredType] of Object.entries(out.inferredTypes)) {
+			result.push(`   ╰ ${criterion}: {${asciiDataType(inferredType)}}`);
+		}
+		return true;
+	},
+	flattenInvolvedNodes: () => {
+		return [];
+	},
+	schema: Joi.object({
+		type:      Joi.string().valid('datatype').required().description('The type of the query.'),
+		criterion: Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.')
+	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
+} as const satisfies SupportedQuery<'datatype'>;

src/queries/query-print.ts

@@ -10,6 +10,7 @@ import type { CallContextQuerySubKindResult } from './catalog/call-context-query
 import type { BaseQueryMeta, BaseQueryResult } from './base-query-format';
 import { printAsMs } from '../util/text/time';
 import { isBuiltIn } from '../dataflow/environments/built-in';
+import { RDataTypeTag, type RDataType } from '../typing/types';
 
 function nodeString(nodeId: NodeId | { id: NodeId, info?: object}, formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
@@ -76,6 +77,16 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 	return formatter === markdownFormatter ? textWithTooltip(acc, JSON.stringify(ids)) : acc;
 }
 
+export function asciiDataType(type: RDataType): string {
+	if(type.tag === RDataTypeTag.Function) {
+		return `Function(${type.parameterTypes.entries().toArray().map(([key, type]) => `${key}: ${asciiDataType(type)}`).join(', ')}) -> ${asciiDataType(type.returnType)}`;
+	} else if(type.tag === RDataTypeTag.List) {
+		return `List(${asciiDataType(type.elementType)})`;
+	} else {
+		return type.tag;
+	}
+}
+
 export function asciiSummaryOfQueryResult(formatter: OutputFormatter, totalInMs: number, results: QueryResults<SupportedQueryTypes>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const result: string[] = [];
 

src/queries/query.ts

@@ -43,6 +43,7 @@ import { OriginQueryDefinition } from './catalog/origin-query/origin-query-forma
 import type { LinterQuery } from './catalog/linter-query/linter-query-format';
 import { LinterQueryDefinition } from './catalog/linter-query/linter-query-format';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { DatatypeQueryDefinition, type DatatypeQuery } from './catalog/datatype-query/datatype-query-format';
 import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
 import { ControlFlowQueryDefinition } from './catalog/control-flow-query/control-flow-query-format';
 
@@ -57,6 +58,7 @@ export type Query = CallContextQuery
 	| DataflowClusterQuery
 	| StaticSliceQuery
 	| LineageQuery
+	| DatatypeQuery
 	| DependenciesQuery
 	| LocationMapQuery
 	| HappensBeforeQuery
@@ -97,6 +99,7 @@ export const SupportedQueries = {
 	'dataflow-cluster': ClusterQueryDefinition,
 	'static-slice':     StaticSliceQueryDefinition,
 	'lineage':          LineageQueryDefinition,
+	'datatype':         DatatypeQueryDefinition,
 	'dependencies':     DependenciesQueryDefinition,
 	'location-map':     LocationMapQueryDefinition,
 	'search':           SearchQueryDefinition,

src/r-bridge/lang-4.x/ast/model/model.ts

@@ -31,7 +31,7 @@ export type NoInfo = object;
  * Will be used to reconstruct the source of the given element in the R-ast.
  * This will not be part of most comparisons as it is mainly of interest to the reconstruction of R code.
  */
-interface Source {
+export interface Source {
 	/**
    * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
    * element.

src/r-bridge/lang-4.x/ast/model/processing/decorate.ts

@@ -9,7 +9,7 @@
  * @module
  */
 
-import type { NoInfo, RNode } from '../model';
+import type { NoInfo, RNode, Source } from '../model';
 import { guard } from '../../../../../util/assert';
 import type { SourceRange } from '../../../../../util/range';
 import { BiMap } from '../../../../../util/collections/bimap';
@@ -463,3 +463,67 @@ function createFoldForFunctionArgument<OtherInfo>(info: FoldInfo<OtherInfo>) {
 		return decorated;
 	};
 }
+
+
+export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down = (_node, down) => down): RNode<NewInfo> {
+	const fullInfoMapper = (node: RNode<OldInfo>, down: Down): NewInfo & Source => {
+		const sourceInfo = {
+			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),
+			...(node.info.fullLexeme !== undefined ? { fullLexeme: node.info.fullLexeme } : {}),
+			...(node.info.additionalTokens !== undefined ? { additionalTokens: node.info.additionalTokens } : {}),
+			...(node.info.file !== undefined ? { file: node.info.file } : {})
+		};
+		const mappedInfo = infoMapper(node, down);
+		return { ...sourceInfo, ...mappedInfo };
+	};
+
+	function updateInfo(n: RNode<OldInfo>, down: Down): RNode<NewInfo> {
+		(n.info as NewInfo) = fullInfoMapper(n, down);
+		return n as unknown as RNode<NewInfo>;
+	}
+
+	return foldAstStateful(ast, down, {
+		down:         downUpdater,
+		foldNumber:   updateInfo,
+		foldString:   updateInfo,
+		foldLogical:  updateInfo,
+		foldSymbol:   updateInfo,
+		foldAccess:   (node, _name, _access, down) => updateInfo(node, down),
+		foldBinaryOp: (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldPipe:     (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldUnaryOp:  (op, _operand, down) => updateInfo(op, down),
+		loop:         {
+			foldFor:    (loop, _variable, _vector, _body, down) => updateInfo(loop, down),
+			foldWhile:  (loop, _condition, _body, down) => updateInfo(loop, down),
+			foldRepeat: (loop, _body, down) => updateInfo(loop, down),
+			foldNext:   (next, down) => updateInfo(next, down),
+			foldBreak:  (next, down) => updateInfo(next, down),
+		},
+		other: {
+			foldComment:       (comment, down) => updateInfo(comment, down),
+			foldLineDirective: (comment, down) => updateInfo(comment, down),
+		},
+		foldIfThenElse: (ifThenExpr, _condition, _then, _otherwise, down ) =>
+			updateInfo(ifThenExpr, down),
+		foldExprList: (exprList, _grouping, _expressions, down) => updateInfo(exprList, down),
+		functions:    {
+			foldFunctionDefinition: (definition, _parameters, _body, down) => updateInfo(definition, down),
+			/** folds named and unnamed function calls */
+			foldFunctionCall:       (call, _functionNameOrExpression, _args, down) => updateInfo(call, down),
+			/** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
+			foldArgument:           (argument, _name, _value, down) => updateInfo(argument, down),
+			/** The `defaultValue` is `undefined` if the argument was not initialized with a default value */
+			foldParameter:          (parameter, _name, _defaultValue, down) => updateInfo(parameter, down)
+		}
+	});
+}
+
+export function mapNormalizedAstInfo<OldInfo extends ParentInformation, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo>) => NewInfo): NormalizedAst<NewInfo> {
+	for(const [id, node] of normalizedAst.idMap.entries()) {
+		if(id === node.info.id) { // we skip virtual nodes
+			(node.info as unknown as NewInfo) = infoMapper(node);
+		}
+	}
+
+	return normalizedAst as unknown as NormalizedAst<NewInfo>;
+}

src/typing/base-types.ts

@@ -0,0 +1,56 @@
+import { RDataTypeTag } from './types';
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export enum RBaseType {
+    NILSXP     = 'NULL',
+	LGLSXP     = 'logical',
+    INTSXP     = 'integer',
+    REALSXP    = 'double',
+	CPLXSXP    = 'complex',
+    STRSXP     = 'character',
+    VECSXP     = 'list',
+    RAWSXP     = 'raw',
+    CLOSXP     = 'closure',
+    SPECIALSXP = 'special',
+    BUILTINSXP = 'builtin',
+    ENVSXP     = 'environment',
+    // S4SXP      = 'S4',
+    SYMSXP     = 'symbol',
+    LANGSXP    = 'language',
+    // LISTSXP    = 'pairlist',
+    EXPRSXP    = 'expression',
+    // EXTPTRSXP  = 'externalptr',
+    // WEAKREFSXP = 'weakref',
+    // BCODESXP   = 'bytecode',
+    // PROMSXP    = 'promise',
+    // DOTSXP     = '...',
+    // ANYSXP     = 'any',
+}
+
+export function baseTypeToDataTypeTag(baseType: RBaseType): RDataTypeTag {
+	switch(baseType) {
+		case RBaseType.NILSXP:     return RDataTypeTag.Null;
+		case RBaseType.LGLSXP:     return RDataTypeTag.Logical;
+		case RBaseType.INTSXP:     return RDataTypeTag.Integer;
+		case RBaseType.REALSXP:    return RDataTypeTag.Double;
+		case RBaseType.CPLXSXP:    return RDataTypeTag.Complex;
+		case RBaseType.STRSXP:     return RDataTypeTag.String;
+		case RBaseType.VECSXP:     return RDataTypeTag.List;
+		case RBaseType.RAWSXP:     return RDataTypeTag.Raw;
+		case RBaseType.CLOSXP:     return RDataTypeTag.Function;
+		case RBaseType.SPECIALSXP: return RDataTypeTag.Function; // Special functions are a kind of function
+		case RBaseType.BUILTINSXP: return RDataTypeTag.Function; // Builtin functions are a kind of function
+		case RBaseType.ENVSXP:     return RDataTypeTag.Environment;
+		// case RBaseType.S4SXP:      return RDataTypeTag.Unknown; // Not yet supported
+		case RBaseType.SYMSXP:     return RDataTypeTag.Language; // Symbols are a kind of language object
+		case RBaseType.LANGSXP:    return RDataTypeTag.Language;
+		// case RBaseType.LISTSXP:    return RDataTypeTag.List; // Not supported
+		case RBaseType.EXPRSXP:    return RDataTypeTag.Language; // Expressions are a kind of language object
+		// case RBaseType.EXTPTRSXP:  return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.WEAKREFSXP: return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.BCODESXP:   return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.PROMSXP:    return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.DOTSXP:     return RDataTypeTag.Language; // Not included in the type system
+		// case RBaseType.ANYSXP:     return RDataTypeTag.Unknown; // Not supported
+	}
+}