@eagleoutice/flowr 2.9.14 → 2.10.2

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

@@ -7,10 +7,7 @@ const parse_1 = require("../../../slicing/criterion/parse");
 const df_helper_1 = require("../../../dataflow/graph/df-helper");
 const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
 /**
- * Execute static slice queries, catching duplicates with the same fingerprint
- * @param analyzer - The basic query data containing the analyzer
- * @param queries - The static slice queries to execute
- * @returns The results of the static slice queries
+ * Execute a provenance query collection, {@link Dataflow.provenance}
  */
 async function executeProvenanceQuery({ analyzer }, queries) {
     const start = Date.now();
@@ -20,9 +17,9 @@ async function executeProvenanceQuery({ analyzer }, queries) {
     for (const query of queries) {
         const key = query.criterion;
         if (results[key]) {
-            log_1.log.warn(`Duplicate Key for provenance query: ${key}, skipping...`);
+            log_1.log.warn(`Duplicate key for provenance query: ${key}, skipping...`);
         }
-        const criterionId = parse_1.SingleSlicingCriterion.tryParse(key, nast.idMap) ?? key;
+        const criterionId = parse_1.SlicingCriterion.tryParse(key, nast.idMap) ?? key;
         const provenanceNode = nast.idMap.get(criterionId);
         const fdef = r_function_definition_1.RFunctionDefinition.wrappingFunctionDefinition(provenanceNode, nast.idMap);
         results[key] = Array.from(df_helper_1.Dataflow.provenance(criterionId, df.graph, fdef ? model_1.RNode.collectAllIds(fdef) : undefined));

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

@@ -1,5 +1,5 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ParsedQueryLine } from '../../query';
 import Joi from 'joi';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -10,7 +10,7 @@ import { executeProvenanceQuery } from './provenance-query-executor';
 export interface ProvenanceQuery extends BaseQueryFormat {
     readonly type: 'provenance';
     /** The slicing criterion to use as a start*/
-    readonly criterion: SingleSlicingCriterion;
+    readonly criterion: SlicingCriterion;
     /** Whether to stop on fdef boundaries */
     readonly restrictFdef?: boolean;
 }

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

@@ -25,7 +25,7 @@ async function executeResolveValueQuery({ analyzer }, queries) {
             log_1.log.warn(`Duplicate Key for resolve-value-query: ${key}, skipping...`);
         }
         const values = query.criteria
-            .map(criteria => parse_1.SingleSlicingCriterion.parse(criteria, idMap))
+            .map(criteria => parse_1.SlicingCriterion.parse(criteria, idMap))
             .flatMap(ident => (0, alias_tracking_1.resolveIdToValue)(ident, { graph, full: true, idMap, resolve: analyzer.flowrConfig.solver.variables, ctx: analyzer.inspectContext() }));
         results[key] = {
             values: values

package/queries/query.d.ts

@@ -33,11 +33,12 @@ import type { CallGraphQuery } from './catalog/call-graph-query/call-graph-query
 import type { InspectRecursionQuery } from './catalog/inspect-recursion-query/inspect-recursion-query-format';
 import type { DoesCallQuery } from './catalog/does-call-query/does-call-query-format';
 import type { InspectExceptionQuery } from './catalog/inspect-exceptions-query/inspect-exception-query-format';
+import type { InputSourcesQuery } from './catalog/input-sources-query/input-sources-query-format';
 import type { ProvenanceQuery } from './catalog/provenance-query/provenance-query-format';
 /**
  * These are all queries that can be executed from within flowR
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DoesCallQuery | CallGraphQuery | ControlFlowQuery | DataflowLensQuery | FilesQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectExceptionQuery | InspectHigherOrderQuery | InspectRecursionQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery | ProvenanceQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DoesCallQuery | CallGraphQuery | ControlFlowQuery | DataflowLensQuery | FilesQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectExceptionQuery | InspectHigherOrderQuery | InspectRecursionQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery | ProvenanceQuery | InputSourcesQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -164,6 +165,13 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
+    readonly 'input-sources': {
+        readonly executor: typeof import("./catalog/input-sources-query/input-sources-query-executor").executeInputSourcesQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfig) => ParsedQueryLine<"input-sources">;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
     readonly dependencies: {
         readonly executor: typeof import("./catalog/dependencies-query/dependencies-query-executor").executeDependenciesQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;

package/queries/query.js

@@ -40,6 +40,7 @@ const call_graph_query_format_1 = require("./catalog/call-graph-query/call-graph
 const inspect_recursion_query_format_1 = require("./catalog/inspect-recursion-query/inspect-recursion-query-format");
 const does_call_query_format_1 = require("./catalog/does-call-query/does-call-query-format");
 const inspect_exception_query_format_1 = require("./catalog/inspect-exceptions-query/inspect-exception-query-format");
+const input_sources_query_format_1 = require("./catalog/input-sources-query/input-sources-query-format");
 const provenance_query_format_1 = require("./catalog/provenance-query/provenance-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
@@ -56,6 +57,7 @@ exports.SupportedQueries = {
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,
     'static-slice': static_slice_query_format_1.StaticSliceQueryDefinition,
     'provenance': provenance_query_format_1.ProvenanceQueryDefinition,
+    'input-sources': input_sources_query_format_1.InputSourcesDefinition,
     'dependencies': dependencies_query_format_1.DependenciesQueryDefinition,
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
     'search': search_query_format_1.SearchQueryDefinition,

package/r-bridge/data/data.d.ts

@@ -422,9 +422,9 @@ export declare const flowrCapabilities: {
                     readonly description: "_Handle `&&`, `||`, ..._";
                 }, {
                     readonly name: "Pipe and Pipe-Bind";
-                    readonly id: "built-in-pipe-and-pipe-bind";
+                    readonly id: "pipe-and-pipe-bind";
                     readonly supported: "partially";
-                    readonly description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.";
+                    readonly description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._; Similarly support the other pipe binds";
                 }, {
                     readonly name: "Sequencing";
                     readonly id: "built-in-sequencing";

package/r-bridge/data/data.js

@@ -537,9 +537,9 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                 },
                                 {
                                     name: 'Pipe and Pipe-Bind',
-                                    id: 'built-in-pipe-and-pipe-bind',
+                                    id: 'pipe-and-pipe-bind',
                                     supported: 'partially',
-                                    description: '_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.'
+                                    description: '_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._; Similarly support the other pipe binds'
                                 },
                                 {
                                     name: 'Sequencing',

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

@@ -219,6 +219,9 @@ export declare const ROther: {
 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}.
+ * For the individual type checks, please consult the individual vertices, e.g. {@link RPipe.is}.
+ * Some vertices also have a {@link RPipe.availableFromRVersion} property that indicates from which R version they are available,
+ * so you can check for that as well if needed.
  * @see {@link DefaultNormalizedAstFold} - for a more powerful way to traverse the normalized AST
  */
 export declare const RNode: {

package/r-bridge/lang-4.x/ast/model/model.js

@@ -120,6 +120,9 @@ exports.ROther = {
 };
 /**
  * Helper object to provide helper functions for {@link RNode|RNodes}.
+ * For the individual type checks, please consult the individual vertices, e.g. {@link RPipe.is}.
+ * Some vertices also have a {@link RPipe.availableFromRVersion} property that indicates from which R version they are available,
+ * so you can check for that as well if needed.
  * @see {@link DefaultNormalizedAstFold} - for a more powerful way to traverse the normalized AST
  */
 exports.RNode = {

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

@@ -1,4 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RArgument, RUnnamedArgument } from './r-argument';
 import type { EmptyArgument } from './r-function-call';
@@ -42,5 +43,19 @@ export declare const RAccess: {
      * Type guard for {@link RIndexAccess} nodes.
      */
     readonly isIndex: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RIndexAccess<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };
 export {};

package/r-bridge/lang-4.x/ast/model/nodes/r-access.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RAccess = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RAccess} AST nodes.
  */
 exports.RAccess = {
+    ...model_1.RNode,
     name: 'RAccess',
     /**
      * Type guard for {@link RAccess} nodes.

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

@@ -1,9 +1,10 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { ParentInformation } from '../processing/decorate';
 import type { NodeId } from '../processing/node-id';
-import type { RFunctionArgument } from './r-function-call';
+import type { PotentiallyEmptyRArgument } from './r-function-call';
 import { EmptyArgument } from './r-function-call';
 import type { BrandedIdentifier } from '../../../../../dataflow/environments/identifier';
 /**
@@ -32,25 +33,47 @@ export declare const RArgument: {
      * @see {@link RArgument.isUnnamed} - to check whether an argument is unnamed
      */
     readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info>;
+    /**
+     * Type guard for arguments that are empty, i.e. {@link EmptyArgument}.
+     */
+    readonly isEmpty: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is typeof EmptyArgument;
+    /**
+     * Type guard for arguments that are _not_ empty, i.e. _not_ {@link EmptyArgument}.
+     */
+    readonly isNotEmpty: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RArgument<Info>;
     /**
      * Type guard for named arguments, i.e. arguments with a name.
      */
-    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info> & {
+    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RArgument<Info> & {
         name: RSymbol<Info, BrandedIdentifier>;
     };
     /**
      * Type guard for unnamed arguments, i.e. arguments without a name.
      */
-    readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RUnnamedArgument<Info>;
+    readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RUnnamedArgument<Info>;
     /**
      * Type guard for arguments with a value, i.e. arguments that are not just placeholders without a value.
      */
     readonly isWithValue: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info> & {
         value: RNode<Info>;
     };
-    readonly getWithId: <OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => Exclude<RFunctionArgument<OtherInfo & ParentInformation>, typeof EmptyArgument> | undefined;
+    readonly getWithId: <OtherInfo>(args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => Exclude<PotentiallyEmptyRArgument<OtherInfo & ParentInformation>, typeof EmptyArgument> | undefined;
     /**
      * Retrieve the value of the argument with the given id from the list of arguments.
      */
-    readonly getValue: <OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => RNode<OtherInfo> | undefined;
+    readonly getValue: <OtherInfo>(args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => RNode<OtherInfo> | undefined;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<ParentInformation>) => NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>) => Set<NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation>, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => RNode<OtherInfo & ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & ParentInformation> | undefined, idMap: Map<NodeId, RNode<OtherInfo & ParentInformation>>) => Generator<RNode<OtherInfo & ParentInformation>>;
+    readonly depth: (this: void, node: RNode<ParentInformation>, idMap: Map<NodeId, RNode<ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>, stop: (node: RNode<OtherInfo & ParentInformation>) => boolean) => Set<NodeId>;
+    readonly lexeme: <R extends RNode<ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-argument.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RArgument = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 const r_function_call_1 = require("./r-function-call");
 /**
  * Helper for working with {@link RArgument} AST nodes.
  */
 exports.RArgument = {
+    ...model_1.RNode,
     name: 'RArgument',
     /**
      * Type guard for {@link RArgument} nodes.
@@ -15,17 +17,29 @@ exports.RArgument = {
     is(node) {
         return node?.type === type_1.RType.Argument;
     },
+    /**
+     * Type guard for arguments that are empty, i.e. {@link EmptyArgument}.
+     */
+    isEmpty(node) {
+        return node === r_function_call_1.EmptyArgument;
+    },
+    /**
+     * Type guard for arguments that are _not_ empty, i.e. _not_ {@link EmptyArgument}.
+     */
+    isNotEmpty(node) {
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node);
+    },
     /**
      * Type guard for named arguments, i.e. arguments with a name.
      */
     isNamed(node) {
-        return exports.RArgument.is(node) && node.name !== undefined;
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node) && node.name !== undefined;
     },
     /**
      * Type guard for unnamed arguments, i.e. arguments without a name.
      */
     isUnnamed(node) {
-        return exports.RArgument.is(node) && node.name === undefined && node.value !== undefined;
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node) && node.name === undefined && node.value !== undefined;
     },
     /**
      * Type guard for arguments with a value, i.e. arguments that are not just placeholders without a value.

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

@@ -1,4 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { OperatorInformationValue } from '../operators';
 /**
@@ -23,4 +24,18 @@ export declare const RBinaryOp: {
      * Get the operator information for a binary operator node.
      */
     readonly getOperatorInfo: <Info = object>(node: RBinaryOp<Info>) => OperatorInformationValue | undefined;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-binary-op.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RBinaryOp = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 const operators_1 = require("../operators");
 /**
  * Helper for working with {@link RBinaryOp} AST nodes.
  */
 exports.RBinaryOp = {
+    ...model_1.RNode,
     name: 'RBinaryOp',
     /**
      * Type guard for {@link RBinaryOp} nodes.

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

@@ -1,4 +1,5 @@
 import type { Leaf, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 /**
  * A `break` statement.
@@ -15,4 +16,18 @@ export declare const RBreak: {
      * Type guard for {@link RBreak} nodes.
      */
     readonly is: <Info = object>(this: void, node: unknown) => node is RBreak<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-break.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RBreak = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RBreak} AST nodes.
  */
 exports.RBreak = {
+    ...model_1.RNode,
     name: 'RBreak',
     /**
      * Type guard for {@link RBreak} nodes.

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

@@ -1,4 +1,5 @@
 import type { Leaf, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 /**
  * ```r
@@ -17,4 +18,18 @@ export declare const RComment: {
      * Type guard for {@link RComment} nodes.
      */
     readonly is: <Info = object>(this: void, node: unknown) => node is RComment<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-comment.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RComment = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RComment} AST nodes.
  */
 exports.RComment = {
+    ...model_1.RNode,
     name: 'RComment',
     /**
      * Type guard for {@link RComment} nodes.

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

@@ -1,4 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo, RNode, WithChildren } from '../model';
+import type { RAstNodeBase, Location, NoInfo, WithChildren } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
@@ -31,4 +32,18 @@ export declare const RExpressionList: {
      * Returns the grouping symbol at the end of the expression list, if it exists. For example, for an expression list created by `{ ... }`, this would return the symbol for `}`.
      */
     readonly groupEnd: <Info = object>(this: void, node: RExpressionList<Info>) => RSymbol<Info> | undefined;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-expression-list.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RExpressionList = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RExpressionList} AST nodes.
  */
 exports.RExpressionList = {
+    ...model_1.RNode,
     name: 'RExpressionList',
     /**
      * Type guard for {@link RExpressionList} nodes.

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

@@ -1,4 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RExpressionList } from './r-expression-list';
@@ -25,4 +26,18 @@ export declare const RForLoop: {
      * Type guard for RForLoop nodes.
      */
     readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RForLoop<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-for-loop.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RForLoop = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RForLoop} AST nodes.
  */
 exports.RForLoop = {
+    ...model_1.RNode,
     name: 'RForLoop',
     /**
      * Type guard for RForLoop nodes.

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

@@ -1,9 +1,10 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
 export declare const EmptyArgument = "<>";
-export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
+export type PotentiallyEmptyRArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
 /**
  * Calls of functions like `a()` and `foo(42, "hello")`.
  * @see RUnnamedFunctionCall
@@ -13,7 +14,7 @@ export interface RNamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, L
     readonly named: true;
     functionName: RSymbol<Info>;
     /** arguments can be empty, for example when calling as `a(1, ,3)` */
-    readonly arguments: readonly RFunctionArgument<Info>[];
+    readonly arguments: readonly PotentiallyEmptyRArgument<Info>[];
 }
 /**
  * Direct calls of functions like `(function(x) { x })(3)`.
@@ -26,7 +27,7 @@ export interface RUnnamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>,
     /** marks function calls like `3 %xx% 4` which have been written in special infix notation; deprecated in v2 */
     infixSpecial?: boolean;
     /** arguments can be undefined, for example when calling as `a(1, ,3)` */
-    readonly arguments: readonly RFunctionArgument<Info>[];
+    readonly arguments: readonly PotentiallyEmptyRArgument<Info>[];
 }
 export type RFunctionCall<Info = NoInfo> = RNamedFunctionCall<Info> | RUnnamedFunctionCall<Info>;
 /**
@@ -46,4 +47,18 @@ export declare const RFunctionCall: {
      * Type guard for {@link RUnnamedFunctionCall} nodes.
      */
     readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RUnnamedFunctionCall<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RFunctionCall = exports.EmptyArgument = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 exports.EmptyArgument = '<>';
 /**
  * Helper for working with {@link RFunctionCall} AST nodes.
  */
 exports.RFunctionCall = {
+    ...model_1.RNode,
     name: 'RFunctionCall',
     /**
      * Type guard for {@link RFunctionCall} nodes.