@eagleoutice/flowr 2.9.9 → 2.9.11

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 {};

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

@@ -1,3 +1,252 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RNode = exports.ROther = exports.RFunctions = exports.RConstructs = exports.RLoopConstructs = exports.RSingleNode = exports.RConstant = void 0;
+const range_1 = require("../../../../util/range");
+const type_1 = require("./type");
+const r_access_1 = require("./nodes/r-access");
+const visitor_1 = require("./processing/visitor");
+const assert_1 = require("../../../../util/assert");
+/**
+ * Helper object to provide helper functions for {@link RConstant|RConstants}.
+ * @see {@link RNode} - for more general helper functions for all nodes
+ */
+exports.RConstant = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return t === type_1.RType.Number || t === type_1.RType.String || t === type_1.RType.Logical;
+    },
+    /**
+     * A set of all types of constants in the normalized AST, i.e. number, string and logical constants.
+     */
+    constantTypes: new Set([type_1.RType.Number, type_1.RType.String, type_1.RType.Logical])
+};
+/**
+ * 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.
+ */
+exports.RSingleNode = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return t === type_1.RType.Comment || t === type_1.RType.Symbol || exports.RConstant.constantTypes.has(t) || t === type_1.RType.Break || t === type_1.RType.Next || t === type_1.RType.LineDirective;
+    },
+    /**
+     * A set of all types of single nodes in the normalized AST, i.e. comment, symbol, constant, break, next and line directive nodes.
+     */
+    singleNodeTypes: new Set([type_1.RType.Comment, type_1.RType.Symbol, type_1.RType.Break, type_1.RType.Next, type_1.RType.LineDirective, ...exports.RConstant.constantTypes])
+};
+exports.RLoopConstructs = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return t === type_1.RType.ForLoop || t === type_1.RType.RepeatLoop || t === type_1.RType.WhileLoop;
+    },
+    /**
+     * A set of all types of loop constructs in the normalized AST, i.e. for, repeat and while loops.
+     */
+    loopConstructTypes: new Set([type_1.RType.ForLoop, type_1.RType.RepeatLoop, type_1.RType.WhileLoop])
+};
+exports.RConstructs = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return exports.RLoopConstructs.loopConstructTypes.has(t) || t === type_1.RType.IfThenElse;
+    },
+    /**
+     * A set of all types of constructs in the normalized AST, i.e. for, repeat and while loops and if-then-else constructs.
+     */
+    constructTypes: new Set([...exports.RLoopConstructs.loopConstructTypes, type_1.RType.IfThenElse])
+};
+exports.RFunctions = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return t === type_1.RType.FunctionDefinition || t === type_1.RType.FunctionCall || t === type_1.RType.Parameter || t === type_1.RType.Argument;
+    },
+    /**
+     * A set of all types of function-related nodes in the normalized AST, i.e. function definitions, function calls, parameters and arguments.
+     */
+    functionTypes: new Set([type_1.RType.FunctionDefinition, type_1.RType.FunctionCall, type_1.RType.Parameter, type_1.RType.Argument])
+};
+exports.ROther = {
+    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.
+     */
+    is(node) {
+        if (!node) {
+            return false;
+        }
+        const t = node.type;
+        return t === type_1.RType.Comment || t === type_1.RType.LineDirective;
+    }
+};
+/**
+ * Helper object to provide helper functions for {@link RNode|RNodes}.
+ * @see {@link DefaultNormalizedAstFold} - for a more powerful way to traverse the normalized AST
+ */
+exports.RNode = {
+    name: 'RNode',
+    /**
+     * A helper function to retrieve the location of a given node, if available.
+     * @see SourceLocation.fromNode
+     */
+    getLocation(node) {
+        return range_1.SourceLocation.fromNode(node);
+    },
+    /**
+     * A helper function to retrieve the id of a given node, if available.
+     */
+    getId(node) {
+        return node.info.id;
+    },
+    /**
+     * A helper function to retrieve the type of a given node.
+     */
+    getType(node) {
+        return node.type;
+    },
+    /**
+     * 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
+     */
+    visitAst(nodes, onVisit, onExit) {
+        return new visitor_1.NodeVisitor(onVisit, onExit).visit(nodes);
+    },
+    /**
+     * 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
+     */
+    collectAllIds(nodes) {
+        const ids = new Set();
+        exports.RNode.visitAst(nodes, node => {
+            ids.add(node.info.id);
+        });
+        return ids;
+    },
+    /**
+     * Collects all direct children of a given node, i.e. all nodes that are directly reachable via a property of the given node.
+     */
+    directChildren(node) {
+        const type = node.type;
+        switch (type) {
+            case type_1.RType.FunctionCall: return [node.named ? node.functionName : node.calledFunction, ...node.arguments];
+            case type_1.RType.FunctionDefinition: return [...node.parameters, node.body];
+            case type_1.RType.ExpressionList: return node.grouping ? [node.grouping[0], ...node.children, node.grouping[1]] : node.children;
+            case type_1.RType.ForLoop: return [node.variable, node.vector, node.body];
+            case type_1.RType.WhileLoop: return [node.condition, node.body];
+            case type_1.RType.RepeatLoop: return [node.body];
+            case type_1.RType.IfThenElse: return node.otherwise ? [node.condition, node.then, node.otherwise] : [node.condition, node.then];
+            case type_1.RType.BinaryOp:
+            case type_1.RType.Pipe: return [node.lhs, node.rhs];
+            case type_1.RType.UnaryOp: return [node.operand];
+            case type_1.RType.Parameter: return node.defaultValue ? [node.name, node.defaultValue] : [node.name];
+            case type_1.RType.Argument: return node.name && node.value ? [node.name, node.value] : node.name ? [node.name] : node.value ? [node.value] : [];
+            case type_1.RType.Access: return r_access_1.RAccess.isIndex(node) ? [node.accessed, ...node.access] : [node.accessed];
+            case type_1.RType.Symbol:
+            case type_1.RType.Logical:
+            case type_1.RType.Number:
+            case type_1.RType.String:
+            case type_1.RType.Comment:
+            case type_1.RType.Break:
+            case type_1.RType.Next:
+            case type_1.RType.LineDirective: return [];
+            default:
+                (0, assert_1.assertUnreachable)(type);
+        }
+    },
+    /**
+     * 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.
+     */
+    directParent(node, idMap) {
+        const parentId = node.info.parent;
+        if (parentId === undefined) {
+            return undefined;
+        }
+        return idMap.get(parentId);
+    },
+    /**
+     * 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.
+     */
+    depth(node, idMap) {
+        let depth = 0;
+        let currentNode = node;
+        while (currentNode) {
+            currentNode = exports.RNode.directParent(currentNode, idMap);
+            depth++;
+        }
+        return depth;
+    },
+    /**
+     * 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
+     */
+    collectAllIdsWithStop(nodes, stop) {
+        const ids = new Set();
+        exports.RNode.visitAst(nodes, node => {
+            if (stop(node)) {
+                return true;
+            }
+            ids.add(node.info.id);
+            return false;
+        });
+        return ids;
+    },
+    /**
+     * 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.
+     */
+    lexeme(node) {
+        return node?.info.fullLexeme ?? node?.lexeme;
+    }
+};
 //# sourceMappingURL=model.js.map

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

@@ -1,4 +1,5 @@
-import type { RawRType, RType } from '../../type';
+import type { RawRType } from '../../type';
+import { RType } from '../../type';
 import type { Location } from '../../model';
 import type { MergeableRecord } from '../../../../../../util/objects';
 /**
@@ -10,3 +11,12 @@ export interface RDelimiter extends MergeableRecord, Location {
     readonly lexeme: string;
     readonly subtype: RawRType;
 }
+/**
+ * Helper for working with {@link RDelimiter} AST nodes.
+ */
+export declare const RDelimiter: {
+    /**
+     * Type guard for {@link RDelimiter} nodes.
+     */
+    readonly is: (this: void, node: unknown) => node is RDelimiter;
+};

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

@@ -1,3 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RDelimiter = void 0;
+const type_1 = require("../../type");
+/**
+ * Helper for working with {@link RDelimiter} AST nodes.
+ */
+exports.RDelimiter = {
+    /**
+     * Type guard for {@link RDelimiter} nodes.
+     */
+    is(node) {
+        return typeof node === 'object' && node !== null && 'type' in node && node.type === type_1.RType.Delimiter;
+    }
+};
 //# sourceMappingURL=r-delimiter.js.map

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

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RArgument, RUnnamedArgument } from './r-argument';
 import type { EmptyArgument } from './r-function-call';
 /**
@@ -25,4 +25,22 @@ export interface RIndexAccess<Info = NoInfo> extends RAccessBase<Info> {
     access: readonly (RArgument<Info> | typeof EmptyArgument)[];
 }
 export type RAccess<Info = NoInfo> = RNamedAccess<Info> | RIndexAccess<Info>;
+/**
+ * Helper for working with {@link RAccess} AST nodes.
+ */
+export declare const RAccess: {
+    readonly name: "RAccess";
+    /**
+     * Type guard for {@link RAccess} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RAccess<Info>;
+    /**
+     * Type guard for {@link RNamedAccess} nodes.
+     */
+    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RNamedAccess<Info>;
+    /**
+     * Type guard for {@link RIndexAccess} nodes.
+     */
+    readonly isIndex: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RIndexAccess<Info>;
+};
 export {};

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

@@ -1,3 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAccess = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RAccess} AST nodes.
+ */
+exports.RAccess = {
+    name: 'RAccess',
+    /**
+     * Type guard for {@link RAccess} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.Access;
+    },
+    /**
+     * Type guard for {@link RNamedAccess} nodes.
+     */
+    isNamed(node) {
+        return exports.RAccess.is(node) && (node.operator === '$' || node.operator === '@');
+    },
+    /**
+     * Type guard for {@link RIndexAccess} nodes.
+     */
+    isIndex(node) {
+        return exports.RAccess.is(node) && (node.operator === '[' || node.operator === '[[');
+    }
+};
 //# sourceMappingURL=r-access.js.map

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 { RType } from '../type';
+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 { EmptyArgument } from './r-function-call';
 import type { BrandedIdentifier } from '../../../../../dataflow/environments/identifier';
 /**
  * Represents a named or unnamed argument of a function definition in R.
@@ -13,11 +14,43 @@ export interface RArgument<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     name: RSymbol<Info, BrandedIdentifier> | undefined;
     value: RNode<Info> | undefined;
 }
+/**
+ * Represents an unnamed argument of a function definition in R, i.e. an argument without a name.
+ * For the helper object, see {@link RArgument.isUnnamed}.
+ */
 export interface RUnnamedArgument<Info = NoInfo> extends RArgument<Info> {
     name: undefined;
     value: RNode<Info>;
 }
 /**
- * Retrieve the argument with the given id from the list of arguments.
+ * Helper for working with {@link RArgument} AST nodes.
  */
-export declare function getArgumentWithId<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined): RFunctionArgument<OtherInfo & ParentInformation> | undefined;
+export declare const RArgument: {
+    readonly name: "RArgument";
+    /**
+     * Type guard for {@link RArgument} nodes.
+     * @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 named arguments, i.e. arguments with a name.
+     */
+    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | 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>;
+    /**
+     * 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;
+    /**
+     * 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;
+};