@eagleoutice/flowr 2.9.10 → 2.9.12

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -5,16 +5,15 @@ exports.satisfiesCallTargets = satisfiesCallTargets;
 exports.getValueOfArgument = getValueOfArgument;
 exports.identifyLinkToLastCallRelation = identifyLinkToLastCallRelation;
 exports.identifyLinkToLastCallRelationSync = identifyLinkToLastCallRelationSync;
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const graph_1 = require("../../../dataflow/graph/graph");
 const simple_visitor_1 = require("../../../control-flow/simple-visitor");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const edge_1 = require("../../../dataflow/graph/edge");
 const resolve_by_name_1 = require("../../../dataflow/environments/resolve-by-name");
 const identifier_1 = require("../../../dataflow/environments/identifier");
-const built_in_1 = require("../../../dataflow/environments/built-in");
 const assert_1 = require("../../../util/assert");
 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 cascade_action_1 = require("./cascade-action");
 const cfg_kind_1 = require("../../../project/cfg-kind");
 var CallTargets;
@@ -49,7 +48,7 @@ function satisfiesCallTargets(info, graph, callTarget) {
          * including any potential built-in mapping.
          */
         const reResolved = (0, resolve_by_name_1.resolveByName)(info.name, info.environment, identifier_1.ReferenceType.Unknown);
-        if (reResolved?.some(t => (0, built_in_1.isBuiltIn)(t.definedAt))) {
+        if (reResolved?.some(t => node_id_1.NodeId.isBuiltIn(t.definedAt))) {
             builtIn = true;
         }
     }
@@ -63,7 +62,7 @@ function satisfiesCallTargets(info, graph, callTarget) {
         case CallTargets.Any:
             return callTargets;
         case CallTargets.OnlyGlobal:
-            if (callTargets.every(built_in_1.isBuiltIn)) {
+            if (callTargets.every(node_id_1.NodeId.isBuiltIn)) {
                 return builtIn ? ['built-in'] : [];
             }
             else {
@@ -94,7 +93,7 @@ function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
     const totalIndex = argument.name ? call.args.findIndex(arg => graph_1.FunctionArgument.hasName(arg, argument.name)) : -1;
     let refAtIndex;
     if (totalIndex < 0) {
-        const references = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);
+        const references = call.args.filter(graph_1.FunctionArgument.isPositional).map(graph_1.FunctionArgument.getReference);
         refAtIndex = references[argument.index];
     }
     else {

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

@@ -11,6 +11,7 @@ const identify_link_to_last_call_relation_1 = require("../call-context-query/ide
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
 const assert_1 = require("../../../util/assert");
 const log_1 = require("../../../util/log");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
 /**
  * Executes a dependencies query.
  */
@@ -185,7 +186,7 @@ function getResults(queries, { dataflow, config, normalize }, results, kind, fun
         if (get?.type === type_1.RType.Argument) {
             get = get.value;
         }
-        return get?.info.fullLexeme ?? get?.lexeme;
+        return model_1.RNode.lexeme(get);
     }
 }
 function collectValuesFromLinks(args, data, linkedIds) {

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

@@ -14,10 +14,11 @@ 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 visualize_functions_1 = require("./function-info/visualize-functions");
-const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const test_functions_1 = require("./function-info/test-functions");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const r_project_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-project");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
 exports.Unknown = 'unknown';
 exports.DefaultDependencyCategories = {
     'library': {
@@ -27,14 +28,14 @@ exports.DefaultDependencyCategories = {
         /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
         additionalAnalysis: async (data, ignoreDefault, _functions, _queryResults, result) => {
             if (!ignoreDefault) {
-                (0, visitor_1.visitAst)((await data.analyzer.normalize()).ast.files.map(f => f.root), n => {
+                r_project_1.RProject.visitAst((await data.analyzer.normalize()).ast, node => {
                     let ns;
-                    if (n.type === type_1.RType.Symbol && (ns = identifier_1.Identifier.getNamespace(n.content)) !== undefined) {
+                    if (node.type === type_1.RType.Symbol && (ns = identifier_1.Identifier.getNamespace(node.content)) !== undefined) {
                         const dep = data.analyzer.inspectContext().deps.getDependency(ns);
                         /* we should improve the identification of ':::' */
                         result.push({
-                            nodeId: n.info.id,
-                            functionName: (n.info.fullLexeme ?? n.lexeme).includes(':::') ? ':::' : '::',
+                            nodeId: node.info.id,
+                            functionName: model_1.RNode.lexeme(node).includes(':::') ? ':::' : '::',
                             value: ns,
                             versionConstraints: dep?.versionConstraints,
                             derivedVersion: dep?.derivedVersion,

package/queries/catalog/dependencies-query/function-info/library-functions.js

@@ -13,6 +13,7 @@ exports.LibraryFunctions = [
     { package: 'easypackages', name: 'from_import', argIdx: 0, argName: 'package', resolveValue: true },
     { package: 'easypackages', name: 'libraries', argIdx: 'unnamed', resolveValue: true },
     { package: 'librarian', name: 'shelf', argIdx: 'unnamed', resolveValue: true },
-    { package: 'devtools', name: 'load_all', argIdx: 0, argName: 'path', resolveValue: true }
+    { package: 'devtools', name: 'load_all', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
+    { package: 'devtools', name: 'load_code', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
 ];
 //# sourceMappingURL=library-functions.js.map

package/queries/catalog/dependencies-query/function-info/read-functions.js

@@ -93,7 +93,7 @@ exports.ReadFunctions = [
     { package: 'XLConnect', name: 'loadWorkbook', argIdx: 0, argName: 'filename', resolveValue: true },
     { package: 'DiagrammeR', name: 'import_graph', argIdx: 0, argName: 'graph_file', resolveValue: true },
     { package: 'DiagrammeR', name: 'open_graph', argIdx: 0, argName: 'file', resolveValue: true },
-    { package: 'highcharter', name: 'download_map_data', argIdx: 0, argName: 'url', resolveValue: true },
+    { package: 'highcharter', name: 'download_map_data', argIdx: 0, argName: 'url', resolveValue: true, defaultValue: 'custom/world.js' },
     { package: 'rvest', name: 'read_html', argIdx: 0, argName: 'x', resolveValue: true },
     { package: 'rvest', name: 'read_html_live', argIdx: 0, argName: 'url', resolveValue: true },
     { package: 'stats', name: 'read.ftable', argIdx: 0, argName: 'file', resolveValue: true },

package/queries/catalog/dependencies-query/function-info/visualize-functions.js

@@ -9,5 +9,13 @@ exports.VisualizeFunctions =
 // plot creation
 default_builtin_config_1.GgPlotCreate.map(f => ({ package: 'ggplot2', name: f })).concat(default_builtin_config_1.TinyPlotCrate.map(f => ({ package: 'tinyplot', name: f })), default_builtin_config_1.GraphicsPlotCreate.map(f => ({ name: f })), 
 // plot modification
-default_builtin_config_1.GgPlotImplicitAddons.concat(default_builtin_config_1.GgPlotAddons).map(f => ({ package: 'ggplot2', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.TinyPlotAddons.map(f => ({ package: 'tinyplot', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.GraphicsPlotAddons.map(f => ({ name: f, linkTo: LinkToPlotCreation })));
+default_builtin_config_1.GgPlotImplicitAddons.concat(default_builtin_config_1.GgPlotAddons).map(f => ({ package: 'ggplot2', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.TinyPlotAddons.map(f => ({ package: 'tinyplot', name: f, linkTo: LinkToPlotCreation })), default_builtin_config_1.GraphicsPlotAddons.map(f => ({ name: f, linkTo: LinkToPlotCreation }))).map(f => {
+    if (f.name !== 'hist') {
+        return f;
+    }
+    else {
+        // ignore if plot is false.
+        return { ...f, ignoreIf: 'arg-false', additionalArgs: { val: { argIdx: 17, argName: 'plot', resolveValue: true } } };
+    }
+});
 //# sourceMappingURL=visualize-functions.js.map

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -115,5 +115,6 @@ exports.WriteFunctions = [
     { package: 'rpolars', name: 'write_csv', argIdx: 0, argName: 'file', resolveValue: true, ignoreIf: 'arg-missing' },
     { package: 'rpolars', name: 'write_ndjson', argIdx: 0, argName: 'file', resolveValue: true, ignoreIf: 'arg-missing' },
     { package: 'rpolars', name: 'write_parquet', argIdx: 0, argName: 'file', resolveValue: true, ignoreIf: 'arg-missing' },
+    { package: 'magick', name: 'image_write', argIdx: 1, argName: 'path', resolveValue: true, ignoreIf: 'arg-missing' },
 ];
 //# sourceMappingURL=write-functions.js.map

package/queries/catalog/does-call-query/does-call-query-executor.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDoesCallQuery = executeDoesCallQuery;
 const log_1 = require("../../../util/log");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const parse_1 = require("../../../slicing/criterion/parse");
-const built_in_1 = require("../../../dataflow/environments/built-in");
 const identifier_1 = require("../../../dataflow/environments/identifier");
 /**
  * Execute does call queries on the given analyzer.
@@ -77,8 +77,8 @@ function findCallersMatchingConstraints(cg, start, constraints) {
             continue;
         }
         visited.add(cur);
-        if ((0, built_in_1.isBuiltIn)(cur)) {
-            const name = (0, built_in_1.dropBuiltInPrefix)(cur);
+        if (node_id_1.NodeId.isBuiltIn(cur)) {
+            const name = node_id_1.NodeId.fromBuiltIn(cur);
             if (constraints({ id: cur, name }, cg)) {
                 return { call: start };
             }

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-format.d.ts

@@ -2,7 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeExceptionQuery } from './inspect-exception-query-executor';
-import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfigOptions } from '../../../config';
 import type { ExceptionPoint } from '../../../dataflow/fn/exceptions-of-function';

package/queries/catalog/inspect-exceptions-query/inspect-exception-query-format.js

@@ -28,11 +28,11 @@ exports.InspectExceptionQueryDefinition = {
         result.push(`Query: ${(0, ansi_1.bold)('inspect-exception', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
         const n = await processed.normalize();
         function getLoc(r) {
-            const node = n.idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r));
+            const node = n.idMap.get(node_id_1.NodeId.normalize(r));
             return node ? range_1.SourceLocation.fromNode(node) : undefined;
         }
         function getLexeme(r) {
-            return n.idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r))?.lexeme ?? String(r);
+            return n.idMap.get(node_id_1.NodeId.normalize(r))?.lexeme ?? String(r);
         }
         for (const [r, v] of Object.entries(out.exceptions)) {
             result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${range_1.SourceLocation.format(getLoc(r))}) ${v.length > 0 ? 'throws exceptions:' : 'does not throw exceptions.'}`);

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.d.ts

@@ -2,7 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeHigherOrderQuery } from './inspect-higher-order-query-executor';
-import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfigOptions } from '../../../config';

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.js

@@ -26,7 +26,7 @@ exports.InspectHigherOrderQueryDefinition = {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('inspect-higher-order', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
         for (const [r, v] of Object.entries(out.higherOrder)) {
-            const node = (await processed.normalize()).idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r));
+            const node = (await processed.normalize()).idMap.get(node_id_1.NodeId.normalize(r));
             const loc = node ? range_1.SourceLocation.fromNode(node) : undefined;
             result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${range_1.SourceLocation.format(loc)}) is ${v ? '' : 'not '}a higher-order function`);
         }

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-format.d.ts

@@ -2,7 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeRecursionQuery } from './inspect-recursion-query-executor';
-import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfigOptions } from '../../../config';

package/queries/catalog/inspect-recursion-query/inspect-recursion-query-format.js

@@ -26,7 +26,7 @@ exports.InspectRecursionQueryDefinition = {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('inspect-recursion', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
         for (const [r, v] of Object.entries(out.recursive)) {
-            const node = (await processed.normalize()).idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r));
+            const node = (await processed.normalize()).idMap.get(node_id_1.NodeId.normalize(r));
             const loc = node ? range_1.SourceLocation.fromNode(node) : undefined;
             result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${range_1.SourceLocation.format(loc)}) is ${v ? '' : 'not '}recursive`);
         }

package/queries/query-print.d.ts

@@ -1,6 +1,6 @@
 import { type OutputFormatter } from '../util/text/ansi';
 import { type Queries, type QueryResults, type SupportedQueryTypes } from './query';
-import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
 /**

package/queries/query-print.js

@@ -5,21 +5,22 @@ exports.summarizeIdsIfTooLong = summarizeIdsIfTooLong;
 exports.asciiSummaryOfQueryResult = asciiSummaryOfQueryResult;
 const ansi_1 = require("../util/text/ansi");
 const query_1 = require("./query");
+const node_id_1 = require("../r-bridge/lang-4.x/ast/model/processing/node-id");
 const html_hover_over_1 = require("../util/html-hover-over");
 const time_1 = require("../util/text/time");
-const built_in_1 = require("../dataflow/environments/built-in");
+const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 function nodeString(nodeId, formatter, idMap) {
     const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
     const id = isObj ? nodeId?.id : nodeId;
     const info = isObj ? nodeId?.info : undefined;
-    if ((0, built_in_1.isBuiltIn)(id)) {
+    if (node_id_1.NodeId.isBuiltIn(id)) {
         return (0, ansi_1.italic)(id, formatter) + (info ? ` (${JSON.stringify(info)})` : '');
     }
     const node = idMap.get(id);
     if (node === undefined) {
         return `UNKNOWN: ${id} (info: ${JSON.stringify(info)})`;
     }
-    return `${(0, ansi_1.italic)('`' + (node.lexeme ?? node.info.fullLexeme ?? 'UNKNOWN') + '`', formatter)} (L.${node.location?.[0]}${info ? ', ' + JSON.stringify(info) : ''})`;
+    return `${(0, ansi_1.italic)('`' + (model_1.RNode.lexeme(node) ?? 'UNKNOWN') + '`', formatter)} (L.${node.location?.[0]}${info ? ', ' + JSON.stringify(info) : ''})`;
 }
 function asciiCallContextSubHit(formatter, results, idMap) {
     const result = [];

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -1,5 +1,6 @@
 import type { SourceRange } from '../../../../util/range';
-import type { RType } from './type';
+import { SourceLocation } from '../../../../util/range';
+import { RType } from './type';
 import type { MergeableRecord } from '../../../../util/objects';
 import type { RNumber } from './nodes/r-number';
 import type { RString } from './nodes/r-string';
@@ -14,7 +15,7 @@ import type { RRepeatLoop } from './nodes/r-repeat-loop';
 import type { RWhileLoop } from './nodes/r-while-loop';
 import type { RIfThenElse } from './nodes/r-if-then-else';
 import type { RFunctionDefinition } from './nodes/r-function-definition';
-import type { RFunctionCall } from './nodes/r-function-call';
+import type { EmptyArgument, RFunctionCall } from './nodes/r-function-call';
 import type { RParameter } from './nodes/r-parameter';
 import type { RArgument } from './nodes/r-argument';
 import type { RExpressionList } from './nodes/r-expression-list';
@@ -23,13 +24,17 @@ import type { RUnaryOp } from './nodes/r-unary-op';
 import type { RBinaryOp } from './nodes/r-binary-op';
 import type { RPipe } from './nodes/r-pipe';
 import type { RDelimiter } from './nodes/info/r-delimiter';
+import type { ParentInformation } from './processing/decorate';
+import type { NodeId } from './processing/node-id';
+import type { OnEnter, OnExit } from './processing/visitor';
+import type { SingleOrArrayOrNothing } from '../../../../abstract-interpretation/normalized-ast-fold';
 /** Simply an empty type constraint used to say that there are additional decorations (see {@link RAstNodeBase}). */
 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.
@@ -98,30 +103,105 @@ export type NamespaceIdentifier = string;
  * represented in the normalized AST.
  */
 export type RConstant<Info> = RNumber<Info> | RString<Info> | RLogical<Info>;
+/**
+ * Helper object to provide helper functions for {@link RConstant|RConstants}.
+ * @see {@link RNode} - for more general helper functions for all nodes
+ */
+export declare const RConstant: {
+    readonly name: "RConstant";
+    /**
+     * Type guard for {@link RConstant} nodes, i.e. checks whether a node is a number, string or logical constant.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RNumber.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RConstant<Info>;
+    /**
+     * A set of all types of constants in the normalized AST, i.e. number, string and logical constants.
+     */
+    readonly constantTypes: ReadonlySet<RType>;
+};
 /**
  * This subtype of {@link RNode} represents all types of {@link Leaf} nodes in the
  * normalized AST.
  */
 export type RSingleNode<Info> = RComment<Info> | RSymbol<Info> | RConstant<Info> | RBreak<Info> | RNext<Info> | RLineDirective<Info>;
+/**
+ * Represents a leaf node in the normalized AST, i.e. a node that does not have any children. This includes comment, symbol, constant, break, next and line directive nodes.
+ */
+export declare const RSingleNode: {
+    readonly name: "RSingleNode";
+    /**
+     * Type guard for {@link RSingleNode} nodes, i.e. checks whether a node is a comment, symbol, constant, break, next or line directive.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RComment.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RSingleNode<Info>;
+    /**
+     * A set of all types of single nodes in the normalized AST, i.e. comment, symbol, constant, break, next and line directive nodes.
+     */
+    readonly singleNodeTypes: ReadonlySet<RType>;
+};
 /**
  * This subtype of {@link RNode} represents all looping constructs in the normalized AST.
  */
 export type RLoopConstructs<Info> = RForLoop<Info> | RRepeatLoop<Info> | RWhileLoop<Info>;
+export declare const RLoopConstructs: {
+    readonly name: "RLoopConstructs";
+    /**
+     * Type guard for {@link RLoopConstructs} nodes, i.e. checks whether a node is a for, repeat or while loop.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RForLoop.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RLoopConstructs<Info>;
+    /**
+     * A set of all types of loop constructs in the normalized AST, i.e. for, repeat and while loops.
+     */
+    readonly loopConstructTypes: ReadonlySet<RType>;
+};
 /**
  * As an extension to {@link RLoopConstructs}, this subtype of {@link RNode} includes
  * the {@link RIfThenElse} construct as well.
  */
 export type RConstructs<Info> = RLoopConstructs<Info> | RIfThenElse<Info>;
+export declare const RConstructs: {
+    readonly name: "RConstructs";
+    /**
+     * Type guard for {@link RConstructs} nodes, i.e. checks whether a node is a for, repeat or while loop or an if-then-else construct.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RForLoop.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RConstructs<Info>;
+    /**
+     * A set of all types of constructs in the normalized AST, i.e. for, repeat and while loops and if-then-else constructs.
+     */
+    readonly constructTypes: ReadonlySet<RType>;
+};
 /**
  * This subtype of {@link RNode} represents all types related to functions
  * (calls and definitions) in the normalized AST.
  */
 export type RFunctions<Info> = RFunctionDefinition<Info> | RFunctionCall<Info> | RParameter<Info> | RArgument<Info>;
+export declare const RFunctions: {
+    readonly name: "RFunctions";
+    /**
+     * Type guard for {@link RFunctions} nodes, i.e. checks whether a node is a function definition, function call, parameter or argument.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RFunctionDefinition.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RFunctions<Info>;
+    /**
+     * A set of all types of function-related nodes in the normalized AST, i.e. function definitions, function calls, parameters and arguments.
+     */
+    readonly functionTypes: ReadonlySet<RType>;
+};
 /**
  * This subtype of {@link RNode} represents all types of otherwise hard to categorize
  * nodes in the normalized AST. At the moment these are the comment-like nodes.
  */
 export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
+export declare const ROther: {
+    readonly name: "ROther";
+    /**
+     * Type guard for {@link ROther} nodes, i.e. checks whether a node is a comment or line directive.
+     * If you need the specific type, please either use the respective type guards (e.g., {@link RComment.is}) or check the `type` node directly.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is ROther<Info>;
+};
 /**
  * The `RNode` type is the union of all possible nodes in the R-ast.
  * It should be used whenever you either not care what kind of
@@ -133,7 +213,74 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * exclusive, some nodes can appear in multiple subtypes.
  * @see {@link recoverName} - to receive the name/lexeme from such a node
  * @see {@link recoverContent} - for a more rigorous approach to get the content of a node within a {@link DataflowGraph|dataflow graph}
+ * @see {@link RNode.getLocation} - to get the location of a node and other helpful functions provided by the {@link RNode} helper object
  */
 export type RNode<Info = NoInfo> = RExpressionList<Info> | RFunctions<Info> | ROther<Info> | RConstructs<Info> | RNamedAccess<Info> | RIndexAccess<Info> | RUnaryOp<Info> | RBinaryOp<Info> | RSingleNode<Info> | RPipe<Info>;
+/**
+ * Helper object to provide helper functions for {@link RNode|RNodes}.
+ * @see {@link DefaultNormalizedAstFold} - for a more powerful way to traverse the normalized AST
+ */
+export declare const RNode: {
+    readonly name: "RNode";
+    /**
+     * A helper function to retrieve the location of a given node, if available.
+     * @see SourceLocation.fromNode
+     */
+    readonly getLocation: (this: void, node: RNode) => SourceLocation | undefined;
+    /**
+     * A helper function to retrieve the id of a given node, if available.
+     */
+    readonly getId: (this: void, node: RNode<ParentInformation>) => NodeId;
+    /**
+     * A helper function to retrieve the type of a given node.
+     */
+    readonly getType: (this: void, node: RNode) => RType;
+    /**
+     * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
+     * @param nodes          - The root id nodes to start collecting from
+     * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
+     * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)
+     * @see {@link RProject.visitAst} - to visit all nodes in a project
+     */
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>) => void;
+    /**
+     * Collects all node ids within a tree given by a respective root node
+     * @param nodes - The root id nodes to start collecting from
+     * @see {@link collectAllIdsWithStop} - to stop collecting at certain nodes
+     * @see {@link RProject.collectAllIds} - to collect all ids within a project
+     */
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>) => Set<NodeId>;
+    /**
+     * Collects all direct children of a given node, i.e. all nodes that are directly reachable via a property of the given node.
+     */
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
+    /**
+     * Returns the direct parent of a node.
+     * Usually, only root nodes do not have a parent, and you can assume that there is a
+     * linear chain of parents leading to the root node.
+     */
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo>>) => RNode<OtherInfo> | undefined;
+    /**
+     * In contrast to the nesting stored in the {@link RNode} structure,
+     * this function calculates the depth of a node by counting the number of parents until the root node is reached.
+     */
+    readonly depth: (this: void, node: RNode, idMap: Map<NodeId, RNode>) => number;
+    /**
+     * Collects all node ids within a tree given by a respective root node, but stops collecting at nodes where the given `stop` function returns `true`.
+     * <p>
+     * This can be used to exclude certain subtrees from the collection, for example to exclude function bodies when collecting ids on the root level.
+     * @param nodes - The root id nodes to start collecting from
+     * @param stop - A function that determines whether to stop collecting at a given node, does not stop by default
+     * @see {@link collectAllIds} - to collect all ids without stopping
+     * @see {@link RProject.collectAllIdsWithStop} - to collect all ids within a project with stopping
+     */
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>, stop: (node: RNode<OtherInfo & ParentInformation>) => boolean) => Set<NodeId>;
+    /**
+     * A helper function to retrieve the lexeme of a given node, if available.
+     * If the `fullLexeme` is available, it will be returned, otherwise the `lexeme` will be returned.
+     */
+    readonly lexeme: <R extends RNode<ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+};
 export type OtherInfoNode = RNode | RDelimiter;
-export {};